/// <summary>
/// Philosopher
///
/// Accepts the philosophers number, Forks and the number of philosophers to eat
/// </summary>
/// <param name="PhilosopherNumber"></param>
/// <param name="Forks"></param>
/// <param name="Footman"></param>
public Philosopher(int PhilosopherNumber, List<Fork> Forks, Semaphore Footman)
{
this.PhilosopherNumber = PhilosopherNumber;
this.Footman = Footman;
RandomNumberGenerator = new Random();
this.Forks = Forks;
}
/// <summary>
/// Initializes a new instance of the <see cref="Mark.Utilities.MAC.Barrier"/> class.
///
/// This is the constructor for the Barrier class, This accepts a uLong as the limit to the barrier
/// Please take note this will be the limit of the Threads that you want to go through at a time.
/// </summary>
/// <param name="Limit">Limit.</param>
public Barrier(ulong Limit)
{
Count = 0;
this.Limit = Limit;
BarrierLock = new object ();
Turnstyle = new Semaphore (Limit);
Turnstyle2 = new Semaphore (0);
}
/// <summary>
/// Bathroom
///
/// Setting up the conditions of the bathroom and the solution of the Starvation problem
/// </summary>
public Bathroom()
{
BathroomSemaphore = new Semaphore (1);
MLightSwitch = new Lightswitch (BathroomSemaphore);
FLightSwitch = new Lightswitch (BathroomSemaphore);
QueueTS = new Semaphore (1);
PopCounter = new Semaphore (3);
}
/// <summary>
/// Initializes a new instance of the <see cref="Mark.Utilities.MAC.ReaderWriter"/> class.
///
/// This Initializes the Reader Writer. All this will do is Initialize all of the global variables for the class to work.
/// </summary>
public ReaderWriter()
{
ReaderWriterLockSemaphore = new Semaphore (1);
ReaderWriterLockLightswitch = new Lightswitch (ReaderWriterLockSemaphore);
ReaderBlock = new Semaphore (1);
WriteBlock = new Semaphore (1);
NumberOfReaders = 0;
ReaderWriterLock = new object ();
}
/// <summary>
/// Initializes a new instance of the <see cref="ClassicConcurrencyProblems.AgentForDining"/> class.
///
/// Initialises all of the variables used to make this possible
/// </summary>
/// <param name="NumberOfServ">Number of serv.</param>
public AgentForDining(ulong NumberOfServ,bool IsTimed, int Time)
{
InformCook = new Semaphore (0);
FullPot = new Semaphore (0);
Pot = NumberOfServ;
Max = NumberOfServ;
Savlock = new Object ();
IsTimedToEnd = IsTimed;
TimeToFinish = Time;
RandomNumberGenerator = new Random ();
stopwatch = new Stopwatch ();
stopwatch.Start();
}
public void TestStart()
{
semaphore = new Semaphore(0);
for (int i = 0; i < 10; i++)
{
Thread aquireTask = new Thread(AquireTokenTest);
aquireTask.Start ();
Thread.Sleep (50);
}
Thread releaseTask = new Thread(ReleaseTokenTest);
releaseTask.Start ();
}
/// <summary>
/// CigaretteSmokersProblemCode Construction
///
/// Set up the programs main semaphores and components
/// </summary>
/// <param name="IsTimed"></param>
/// <param name="Time"></param>
public CigaretteSmokersProblemCode(bool IsTimed,int Time)
{
Tobacco = new Semaphore(0);
Paper = new Semaphore(0);
Match = new Semaphore(0);
TobaccoSem = new Semaphore(0);
PaperSem = new Semaphore(0);
MatchSem = new Semaphore(0);
stopwatch = new Stopwatch ();
stopwatch.Start();
AgentSem = new Semaphore(1);
AgentLock = new object();
IsTobacco = false;
IsPaper = false;
IsMatch = false;
IsItTimed = IsTimed;
TimeToEnd = Time;
RandomNumberGenerator = new Random();
}
public void TestStart()
{
semaphore = new Semaphore(0);
LightswitchTest = new Lightswitch (semaphore);
Thread releaseToken = new Thread(ReleaseToken);
Thread releaseTask = new Thread(AquireTokenLightSwitch);
Thread releaseTask1 = new Thread(AquireTokenLightSwitch);
Thread releaseTask2 = new Thread(AquireTokenSemaPhore);
Thread releaseTask3 = new Thread(AquireTokenSemaPhore);
Thread releaseTask4 = new Thread(AquireTokenLightSwitch2);
Thread releaseTask5 = new Thread(AquireTokenLightSwitch2);
releaseToken.Start ();
releaseTask.Start();
releaseTask1.Start ();
releaseTask2.Start();
releaseTask3.Start();
releaseTask4.Start();
releaseTask5.Start();
}
public void TestStart()
{
semaphore = new Semaphore(0);
TestOne();
Thread.Sleep(8000);
Thread aquireTask1 = new Thread(() => ReleaseToken(3300));
Thread aquireTask2 = new Thread(() => ReleaseToken(3300));
aquireTask1.Start();
aquireTask2.Start();
Thread acquireTask = new Thread(() => AquireToken(3600));
acquireTask.Name = "\t\t Thread One - ";
acquireTask.Start();
Thread acquireTask1 = new Thread(() => AquireToken(3400));
acquireTask1.Name = "\t\t\t Thread Two - ";
acquireTask1.Start();
Thread acquireTask2 = new Thread(() => AquireToken(3000));
acquireTask2.Name = "\t Expected Fail Thread - ";
acquireTask2.Start();
}
/// <summary>
/// Initializes a new instance of the <see cref="Mark.Utilities.MAC.Lightswitch"/> class.
///
/// This allows the creation of the Lightswitch, this accepts a Semaphore as a paramater and only allows this to be passed in
/// this is detrement to what you want to do, make sure you pick the right semaphore to pass in.
/// </summary>
/// <param name="LightswitchSemaphore">Lightswitch semaphore.</param>
public Lightswitch(Semaphore LightswitchSemaphore)
{
ThreadCount = 0;
this.LightswitchSemaphore = LightswitchSemaphore;
LightswitchLock = new object ();
}
/// <summary>
/// Fork
///
/// Construction of a fork with a semaphore.
/// This is to signal if it is in use or not
/// </summary>
/// <param name="ForkInSemaphore"></param>
public Fork(Semaphore ForkInSemaphore)
{
this.ForkInSemaphore = ForkInSemaphore;
}
/// <summary>
/// Initializes a new instance of the <see cref="Mark.Utilities.MAC.Latch"/> class.
///
/// This allows the creation of the Latch and the semaphore that is within the latch,
/// The semaphore will take a argument of 0, this will allow to the open door method to be effective.
/// </summary>
public Latch()
{
LatchSemaphore = new Semaphore (0);
}