public static void Main(){
SimpleHybridLock simpleLock = new SimpleHybridLock();
Task.Run(() => {
Console.WriteLine("Entered ThreadOne");
Console.WriteLine("ThreadOne.SimpleHybridLock.Enter");
simpleLock.Enter();
for(int i=0; i<10; i++){
value = i;
Thread.Sleep(100);
}
Console.WriteLine(value);
simpleLock.Leave();
Console.WriteLine("ThreadOne.SimpleHybridLock.Leave");
});
// Task.Run(() => {
// Console.WriteLine("Entered ThreadTwo");
// Console.WriteLine("ThreadTwo.SimpleHybridLock.Enter");
// simpleLock.Enter();
// for(int i=10; i<20; i++){
// value = i;
// Thread.Sleep(100);
// }
// Console.WriteLine(value);
// simpleLock.Leave();
// Console.WriteLine("ThreadTwo.SimpleHybridLock.Leave");
// });
Thread.Sleep(60000);
}
public static void Go()
{
int x = 0;
const int iterations = 10000000;
var shl = new SimpleHybridLock();
shl.Enter(); x++; shl.Leave();
Stopwatch sw = Stopwatch.StartNew();
for (int i = 0; i < iterations; i++)
{
shl.Enter(); x++; shl.Leave();
}
Console.WriteLine("Incrementing x in simpleHybridLock:{0:N0}", sw.ElapsedMilliseconds);
using (var ahl = new AnotherHybridLock())
{
ahl.Enter(); x++; ahl.Leave();
sw.Restart();
for (int i = 0; i < iterations; i++)
{
ahl.Enter(); x++; ahl.Leave();
}
Console.WriteLine("Incrementing x in AnotherHybridLock: {0:N0}", sw.ElapsedMilliseconds);
}
using (var ahl = new AnotherHybridLock())
{
ahl.Enter(); x++; ahl.Leave();
sw.Restart();
for (int i = 0; i < iterations; i++)
{
ahl.Enter(); x++; ahl.Leave();
}
Console.WriteLine("Incrementing x in AnotherHybridLock: {0:N0}", sw.ElapsedMilliseconds);
}
}
private void OnFrameGeneratedThreadSafe(RawFrame frame)
{
if (FrameReceived == null)
{
return;
}
_hybridLock.Enter();
try
{
FrameReceived.Invoke(frame);
}
finally
{
_hybridLock.Leave();
}
}
public static void Go()
{
Int32 x = 0;
const Int32 iterations = 10000000; // 10 million
// How long does it take to increment x 10 million times
// adding the overhead of calling an uncontended SimpleHybridLock?
var shl = new SimpleHybridLock();
shl.Enter(); x++; shl.Leave();
Stopwatch sw = Stopwatch.StartNew();
for (Int32 i = 0; i < iterations; i++)
{
shl.Enter(); x++; shl.Leave();
}
Console.WriteLine("Incrementing x in SimpleHybridLock: {0:N0}", sw.ElapsedMilliseconds);
// How long does it take to increment x 10 million times
// adding the overhead of calling an uncontended ANotherHybridLock?
using (var ahl = new AnotherHybridLock()) {
ahl.Enter(); x++; ahl.Leave();
sw.Restart();
for (Int32 i = 0; i < iterations; i++)
{
ahl.Enter(); x++; ahl.Leave();
}
Console.WriteLine("Incrementing x in AnotherHybridLock: {0:N0}", sw.ElapsedMilliseconds);
}
using (var oml = new OneManyLock()) {
oml.Enter(true); x++; oml.Leave();
sw.Restart();
for (Int32 i = 0; i < iterations; i++)
{
oml.Enter(true); x++; oml.Leave();
}
Console.WriteLine("Incrementing x in OneManyLock: {0:N0}", sw.ElapsedMilliseconds);
}
using (var rwls = new ReaderWriterLockSlim(LockRecursionPolicy.NoRecursion)) {
rwls.EnterReadLock(); x++; rwls.ExitReadLock();
sw.Restart();
for (Int32 i = 0; i < iterations; i++)
{
rwls.EnterReadLock(); x++; rwls.ExitReadLock();
}
Console.WriteLine("Incrementing x in ReaderWriterLockSlim: {0:N0}", sw.ElapsedMilliseconds);
}
var rwl = new ReaderWriterLock();
rwl.AcquireReaderLock(Timeout.Infinite); x++; rwl.ReleaseReaderLock();
sw.Restart();
for (Int32 i = 0; i < iterations; i++)
{
rwl.AcquireReaderLock(Timeout.Infinite); x++; rwl.ReleaseReaderLock();
}
Console.WriteLine("Incrementing x in ReaderWriterLock: {0:N0}", sw.ElapsedMilliseconds);
Object l = new Object();
Monitor.Enter(l); x++; Monitor.Exit(l);
sw.Restart();
for (Int32 i = 0; i < iterations; i++)
{
Monitor.Enter(l); x++; Monitor.Exit(l);
}
Console.WriteLine("Incrementing x in Monitor: {0:N0}", sw.ElapsedMilliseconds);
sw.Restart();
for (Int32 i = 0; i < iterations; i++)
{
lock (l) { x++; }
}
Console.WriteLine("Incrementing x in lock: {0:N0}", sw.ElapsedMilliseconds);
Console.ReadLine();
}
public static void Go()
{
int x = 0;
const int iterations = 10000000; // 10 million
Stopwatch sw = Stopwatch.StartNew();
for (Int32 i = 0; i < iterations; i++)
{
x++;
}
Console.WriteLine("Incrementing x: {0:N0}", sw.ElapsedMilliseconds);
// How long does it take to increment x 10 million times
// adding the overhead of calling a method that does nothing?
sw.Restart();
for (Int32 i = 0; i < iterations; i++)
{
M(); x++; M();
}
Console.WriteLine("Incrementing x in M: {0:N0}", sw.ElapsedMilliseconds);
// How long does it take to increment x 10 million times
// adding the overhead of calling an uncontended SpinLock?
SpinLock sl = new SpinLock(false);
sw.Restart();
for (Int32 i = 0; i < iterations; i++)
{
Boolean taken = false;
sl.Enter(ref taken); x++; sl.Exit(false);
}
Console.WriteLine("Incrementing x in SpinLock: {0:N0}", sw.ElapsedMilliseconds);
// How long does it take to increment x 10 million times
var shl = new SimpleHybridLock();
shl.Enter();
x++;
shl.Leave();
sw.Restart();
for (int i = 0; i < iterations; i++)
{
shl.Enter();
x++;
shl.Leave();
}
Console.WriteLine("Incrementing x in SimpleHybridLock: {0:N0}", sw.ElapsedMilliseconds);
using (var ahl = new AnotherHybridLock())
{
ahl.Enter();
x++;
ahl.Leave();
sw.Restart();
for (int i = 0; i < iterations; i++)
{
ahl.Enter();
x++;
ahl.Leave();
}
Console.WriteLine("Incrementing x in AnotherHybridLock: {0:N0}", sw.ElapsedMilliseconds);
}
using (SimpleWaitLock swl = new SimpleWaitLock())
{
sw.Restart();
for (Int32 i = 0; i < iterations; i++)
{
swl.Enter(); x++; swl.Leave();
}
Console.WriteLine("Incrementing x in SimpleWaitLock: {0:N0}", sw.ElapsedMilliseconds);
}
//using (var oml = new OneManyLock())
//{
//}
//using (var rwls = new ReaderWriterLockSlim(LockRecursionPolicy.NoRecursion))
//{
// rwls
//}
}