public void TestHasWaiters()
{
Mutex sync = new Mutex();
AbstractQueuedSynchronizer.ConditionObject c = sync.NewCondition();
Pair data = new Pair(sync, c);
Thread t = new Thread(TestHasWaitersRunnable);
try
{
t.Start(data);
Thread.Sleep(SHORT_DELAY_MS);
sync.Acquire(1);
Assert.IsTrue(sync.HasWaiters(c));
Assert.AreEqual(1, sync.GetWaitQueueLength(c));
c.Signal();
sync.Release(1);
Thread.Sleep(SHORT_DELAY_MS);
sync.Acquire(1);
Assert.IsFalse(sync.HasWaiters(c));
Assert.AreEqual(0, sync.GetWaitQueueLength(c));
sync.Release(1);
t.Join(SHORT_DELAY_MS);
Assert.IsFalse(t.IsAlive);
}
catch (Exception)
{
UnexpectedException();
}
}
/// <summary>
/// Acquire read permission.
/// </summary>
public void AcquireReader()
{
// Only allow a single thread through at a time by using a turnstile system
_turnStile.Acquire();
_turnStile.Release();
// Acquire the Switch object, which governs controls over the write permission Mutex
_readPermission.Acquire();
}
/// <summary>
/// Arrive at the Barrier.
/// </summary>
/// <returns>
/// Returns Boolean, representing whether or not all threads have arrived at the Barrier and are now synchronized.
/// </returns>
public Boolean Arrive()
{
Boolean result = false;
// Thread arrives
_turnStile.Acquire();
lock (_lock)
{
_threadCount++;
// If all threads have arrived, open the Barrier and let threads commence with activity
if (_threadCount == _barrierLimit)
{
_actPermission.Release(_barrierLimit);
result = true;
}
else
{
_turnStile.Release();
}
}
// Waiting threads acquire from Semaphore and wait for final thread to trip Barrier
_actPermission.Acquire();
lock (_lock)
{
// Let the threads leave
_threadCount--;
// If the last thread to leave, free the turnstile
if (_threadCount == 0)
{
_turnStile.Release();
}
}
return(result);
}
public void TestGetFirstQueuedThread()
{
Mutex sync = new Mutex();
Thread t1 = new Thread(InterruptedSyncRunnable);
Thread t2 = new Thread(InterruptibleSyncRunnable);
try
{
Assert.IsNull(sync.FirstQueuedThread);
sync.Acquire(1);
t1.Start(sync);
Thread.Sleep(SHORT_DELAY_MS);
Assert.AreEqual(t1, sync.FirstQueuedThread);
t2.Start(sync);
Thread.Sleep(SHORT_DELAY_MS);
Assert.AreEqual(t1, sync.FirstQueuedThread);
t1.Interrupt();
Thread.Sleep(SHORT_DELAY_MS);
Thread.Sleep(SHORT_DELAY_MS);
Assert.AreEqual(t2, sync.FirstQueuedThread);
sync.Release(1);
Thread.Sleep(SHORT_DELAY_MS);
Assert.IsNull(sync.FirstQueuedThread);
t1.Join();
t2.Join();
}
catch (Exception e)
{
UnexpectedException(e);
}
}
public void TestHasContended()
{
Mutex sync = new Mutex();
Thread t1 = new Thread(InterruptedSyncRunnable);
Thread t2 = new Thread(InterruptibleSyncRunnable);
try
{
Assert.IsFalse(sync.HasContended);
sync.Acquire(1);
t1.Start(sync);
Thread.Sleep(SHORT_DELAY_MS);
Assert.IsTrue(sync.HasContended);
t2.Start(sync);
Thread.Sleep(SHORT_DELAY_MS);
Assert.IsTrue(sync.HasContended);
t1.Interrupt();
Thread.Sleep(SHORT_DELAY_MS);
Assert.IsTrue(sync.HasContended);
sync.Release(1);
Thread.Sleep(SHORT_DELAY_MS);
Assert.IsTrue(sync.HasContended);
t1.Join();
t2.Join();
}
catch (Exception e)
{
UnexpectedException(e);
}
}
public void TestGetSharedQueuedThreads()
{
Mutex sync = new Mutex();
Thread t1 = new Thread(InterruptedSyncRunnable);
Thread t2 = new Thread(InterruptibleSyncRunnable);
try {
Assert.IsTrue(sync.SharedQueuedThreads.IsEmpty());
sync.Acquire(1);
Assert.IsTrue(sync.SharedQueuedThreads.IsEmpty());
t1.Start(sync);
Thread.Sleep(SHORT_DELAY_MS);
Assert.IsTrue(sync.SharedQueuedThreads.IsEmpty());
t2.Start(sync);
Thread.Sleep(SHORT_DELAY_MS);
Assert.IsTrue(sync.SharedQueuedThreads.IsEmpty());
t1.Interrupt();
Thread.Sleep(SHORT_DELAY_MS);
Assert.IsTrue(sync.SharedQueuedThreads.IsEmpty());
sync.Release(1);
Thread.Sleep(SHORT_DELAY_MS);
Assert.IsTrue(sync.SharedQueuedThreads.IsEmpty());
t1.Join();
t2.Join();
}
catch (Exception e)
{
UnexpectedException(e);
}
}
public void TestAwaitUnInterruptibly()
{
Mutex sync = new Mutex();
AbstractQueuedSynchronizer.ConditionObject c = sync.NewCondition();
Pair data = new Pair(sync, c);
Thread t = new Thread(TestAwaitUnInterruptiblyRunnable);
try
{
t.Start(data);
Thread.Sleep(SHORT_DELAY_MS);
t.Interrupt();
sync.Acquire(1);
c.Signal();
sync.Release(1);
t.Join(SHORT_DELAY_MS);
Assert.IsFalse(t.IsAlive);
}
catch (Exception e)
{
UnexpectedException(e);
}
}
public void TestSignalAll()
{
Mutex sync = new Mutex();
AbstractQueuedSynchronizer.ConditionObject c = sync.NewCondition();
Pair data = new Pair(sync, c);
Thread t1 = new Thread(TestSignalAllRunnable1);
Thread t2 = new Thread(TestSignalAllRunnable2);
try
{
t1.Start(data);
t2.Start(data);
Thread.Sleep(SHORT_DELAY_MS);
sync.Acquire(1);
c.SignalAll();
sync.Release(1);
t1.Join(SHORT_DELAY_MS);
t2.Join(SHORT_DELAY_MS);
Assert.IsFalse(t1.IsAlive);
Assert.IsFalse(t2.IsAlive);
}
catch (Exception e)
{
UnexpectedException(e);
}
}
public void TestAcquire()
{
Mutex rl = new Mutex();
rl.Acquire(1);
Assert.IsTrue(rl.AccessIsHeldExclusively());
rl.Release(1);
Assert.IsFalse(rl.AccessIsHeldExclusively());
}
/// <summary>
/// Acquire write permission.
/// </summary>
public void AcquireWriter()
{
// Use a seperate turnstile for threads that seek write permission. Writing threads will queue here
_writeTurnStile.Acquire();
// Enter the standard turnstile, acquire the write permission Mutex and release the standard turnstile to allow potential readers to queue
_turnStile.Acquire();
_writePermission.Acquire();
_turnStile.Release();
}
public void SetSail()
{
_permission.Acquire();
//Thread.Sleep(new Random().Next(500, 1500));
Console.WriteLine("\t\t" + Thread.CurrentThread.Name + ": Boat full! Let's go for a boat ride!");
//Thread.Sleep(new Random().Next(1500, 3000));
Console.WriteLine("\t\t\t" + Thread.CurrentThread.Name + ": Boat ride has finished! Let new patrons board.");
_boardPermission.Release();
}
public static void OtherThread()
{
writeMtx.Acquire();
{
Console.WriteLine("Inside OtherThread");
Thread.Sleep(1000);
Console.WriteLine("1 - Other");
Thread.Sleep(1000);
Console.WriteLine("2 - Other");
Thread.Sleep(1000);
Console.WriteLine("3 - Other");
Thread.Sleep(1000);
}
Console.WriteLine("Attempting to release OtherThread writeMtx");
writeMtx.Release();
}
// The logic
protected override void Run()
{
if (PhilosophersProfiler.debug)
{
Console.WriteLine("Inside run()!");
}
while (true)
{
// Some thinking
Thread.Sleep((int)PhilosophersProfiler.timeThinking);
if (PhilosophersProfiler.debug)
{
Console.WriteLine(base.activeThread.Name + " Has finished thinking and wants to eat!");
}
// Attempting to start eating
if (_startLeft)
{
_leftChopstick.Acquire();
_rightChopstick.Acquire();
}
else
{
_rightChopstick.Acquire();
_leftChopstick.Acquire();
}
// Eating
if (PhilosophersProfiler.debug)
{
Console.WriteLine(base.activeThread.Name + " Is now eating food!");
}
++timesEating;
Thread.Sleep((int)PhilosophersProfiler.timeEating);
_rightChopstick.Release();
_leftChopstick.Release();
}
}
public void TestToString()
{
Mutex sync = new Mutex();
String us = sync.ToString();
Assert.IsTrue(us.IndexOf("State = 0") >= 0);
sync.Acquire(1);
String ls = sync.ToString();
Assert.IsTrue(ls.IndexOf("State = 1") >= 0);
}
private void TestAwaitUnInterruptiblyRunnable(object state)
{
Pair data = state as Pair;
Mutex sync = data.first as Mutex;
AbstractQueuedSynchronizer.ConditionObject c =
data.second as AbstractQueuedSynchronizer.ConditionObject;
sync.Acquire(1);
c.AwaitUnInterruptibly();
sync.Release(1);
}
private void TestGetStateRunnable(object state)
{
Mutex sync = state as Mutex;
sync.Acquire(1);
try
{
Thread.Sleep(SMALL_DELAY_MS);
}
catch (Exception e)
{
ThreadUnexpectedException(e);
}
sync.Release(1);
}
public void TestAwaitTimeout()
{
Mutex sync = new Mutex();
AbstractQueuedSynchronizer.ConditionObject c = sync.NewCondition();
try
{
sync.Acquire(1);
Assert.IsFalse(c.Await(SHORT_DELAY_MS) > 0);
sync.Release(1);
}
catch (Exception e)
{
UnexpectedException(e);
}
}
public void TestAwaitUntilTimeout()
{
Mutex sync = new Mutex();
AbstractQueuedSynchronizer.ConditionObject c = sync.NewCondition();
try
{
sync.Acquire(1);
DateTime deadline = DateTime.Now;
Assert.IsFalse(c.AwaitUntil(deadline.AddSeconds(5)));
sync.Release(1);
}
catch (Exception e)
{
UnexpectedException(e);
}
}
public void TestAcquireTimedTimeout()
{
Mutex sync = new Mutex();
sync.Acquire(1);
Thread t = new Thread(TestAcquireTimedTimeoutRunnable);
try
{
t.Start(sync);
t.Join();
sync.Release(1);
}
catch (Exception e)
{
UnexpectedException(e);
}
}
public void TestTryAcquireWhenSynced()
{
Mutex sync = new Mutex();
sync.Acquire(1);
Thread t = new Thread(TestTryAcquireWhenSyncedRunnable);
try
{
t.Start(sync);
t.Join();
sync.Release(1);
}
catch (Exception e)
{
UnexpectedException(e);
}
}
public void TestThreadInterruptedException2()
{
Mutex sync = new Mutex();
sync.Acquire(1);
Thread t = new Thread(TestThreadInterruptedException2Rannable);
try
{
t.Start(sync);
t.Interrupt();
t.Join();
}
catch (Exception e)
{
UnexpectedException(e);
}
}
private void TestAwaitRunnable(object state)
{
Pair data = state as Pair;
Mutex sync = data.first as Mutex;
AbstractQueuedSynchronizer.ConditionObject c =
data.second as AbstractQueuedSynchronizer.ConditionObject;
try
{
sync.Acquire(1);
c.Await();
sync.Release(1);
}
catch (ThreadInterruptedException e)
{
ThreadUnexpectedException(e);
}
}
private void TestAwaitUntilInterruptRunnable(object state)
{
Pair data = state as Pair;
Mutex sync = data.first as Mutex;
AbstractQueuedSynchronizer.ConditionObject c =
data.second as AbstractQueuedSynchronizer.ConditionObject;
try
{
sync.Acquire(1);
c.AwaitUntil(DateTime.Now.AddMilliseconds(10000));
sync.Release(1);
ThreadShouldThrow();
}
catch (ThreadInterruptedException)
{
}
}
private void TestGetWaitQueueLengthRunnable2(object state)
{
Pair data = state as Pair;
Mutex sync = data.first as Mutex;
AbstractQueuedSynchronizer.ConditionObject c = data.second as AbstractQueuedSynchronizer.ConditionObject;
try
{
sync.Acquire(1);
ThreadAssertTrue(sync.HasWaiters(c));
ThreadAssertEquals(1, sync.GetWaitQueueLength(c));
c.Await();
sync.Release(1);
}
catch (ThreadInterruptedException e)
{
ThreadUnexpectedException(e);
}
}
private void TestGetWaitingThreadsRunnable2(object state)
{
Pair data = state as Pair;
Mutex sync = data.first as Mutex;
AbstractQueuedSynchronizer.ConditionObject c =
data.second as AbstractQueuedSynchronizer.ConditionObject;
try
{
sync.Acquire(1);
ThreadAssertFalse(sync.GetWaitingThreads(c).IsEmpty());
c.Await();
sync.Release(1);
}
catch (ThreadInterruptedException e)
{
ThreadUnexpectedException(e);
}
}
public void TestAcquireInterruptibly1()
{
Mutex sync = new Mutex();
sync.Acquire(1);
Thread t = new Thread(InterruptedSyncRunnable);
try
{
t.Start(sync);
Thread.Sleep(SHORT_DELAY_MS);
t.Interrupt();
Thread.Sleep(SHORT_DELAY_MS);
sync.Release(1);
t.Join();
}
catch (Exception e)
{
UnexpectedException(e);
}
}
public void TestGetState()
{
Mutex sync = new Mutex();
sync.Acquire(1);
Assert.IsTrue(sync.AccessIsHeldExclusively());
sync.Release(1);
Assert.IsFalse(sync.AccessIsHeldExclusively());
Thread t = new Thread(TestGetStateRunnable);
try
{
t.Start(sync);
Thread.Sleep(SHORT_DELAY_MS);
Assert.IsTrue(sync.AccessIsHeldExclusively());
t.Join();
Assert.IsFalse(sync.AccessIsHeldExclusively());
}
catch (Exception e)
{
UnexpectedException(e);
}
}
/// <summary>
/// Acquire the Latch.
/// </summary>
public void Acquire()
{
//Acquire and immediately release the Mutex.
_mutex.Acquire();
_mutex.Release();
}
public HeldMutex(Mutex instance)
{
this.instance = instance;
instance.Acquire();
}
public override void Visit(Acquire node)
{
Mutex mutex = thread.Pop().Read().GetAsMutex();
mutex.Acquire(thread);
}
