private static void AcquireToken()
{
{
_testMutex.Acquire();
Console.WriteLine(Thread.CurrentThread.Name + " has acquired a token.\n");
}
}
private void GetChopSticks()
{
switch (_rand.Next(2))
{
case 0:
{
_leftChopStick.Acquire();
Thread.Sleep(_rand.Next(500, 1500));
_rightChopStick.Acquire();
_firstChopStick = Chopsticks.Left;
Console.WriteLine("\t\t" + Thread.CurrentThread.Name + ": I've picked up a chopstick to my left and a chopstick to my right!");
break;
}
default:
{
_rightChopStick.Acquire();
Thread.Sleep(_rand.Next(500, 1500));
_leftChopStick.Acquire();
_firstChopStick = Chopsticks.Right;
Console.WriteLine("\t\t" + Thread.CurrentThread.Name + ": I've picked up a chopstick to my right and a chopstick to my left!");
break;
}
}
Thread.Sleep(_rand.Next(500, 1500));
}
/// <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);
}
private void ActOnAvailabilities()
{
_preventDeadLock.Acquire();
switch (_pusherType)
{
case PusherType.Red:
{
RedCheck();
break;
}
case PusherType.Green:
{
GreenCheck();
break;
}
case PusherType.Blue:
{
BlueCheck();
break;
}
}
_preventDeadLock.Release();
}
/// <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();
}
/// <summary>
/// Acquire the Latch.
/// </summary>
public void Acquire()
{
//Acquire and immediately release the Mutex.
_mutex.Acquire();
_mutex.Release();
}
