The important thing to always remember with locking and mutithreaded applciations is that locking is only effective if all your code that accesses a locked resource plays by the same rules i.e if one thread can lock a resource, all other threads that can access that same resource should use locks before accessing that resource.
Monitor and Lock
The lock keyword is convenienve wrapper for the Monitor class. This means that lock(obj) is the same as Monitor.Enter(obj) (although Monitor has the added functionality to timeout after a period of time if it could not get the lock to the object).
Pulsing events and threads
When a number of threads are waiting to gain a lock on some resource, via code you can signal when the owner thread is completed with the resource. This is known as signalling or pulsing and can be accomplished via Monitor.Pulse, Monitor.PulseAll, ManualResetEvent.Set or even AutoResetEvent.Set.
Soccer Example
So your soccer example below would be coded to include thread locking as follows:
namespace ThreadingSimulation
{
// A Random Activity can be picked up from this enum by a team
public enum RandomGroundStatus
{
Free,
Allotted,
Wet
}
class FootBallGround
{
private Team _currentTeam;
// Set the initial state to true so that the first thread that
// tries to get the lock will succeed
private ManualResetEvent _groundsLock = new ManualResetEvent(true);
public bool Playing(Team obj)
{
// Here the name of the team which is using the ground will be printed
// Once the time is reached to 25 minutes the active thread the lock will
// signal other threads
if (!_groundsLock.WaitOne(10))
return false;
_currentTeam = obj;
// Reset the event handle so that no other thread can come into this method
_groundsLock.Reset();
// Now we start a separate thread to "timeout" this team's lock
// on the football grounds after 25 minutes
ThreadPool.QueueUserWorkItem(WaitForTimeout(25));
}
public void GroundCleaningInProgress(object obj)
{
// Ground cleaning is in progress all of you wait for 10 minutes
}
private void WaitForTimeout(object state)
{
int timeout = (int)state;
// convert the number we specified into a value equivalent in minutes
int milliseconds = timeout * 1000;
int minutes = milliseconds * 60;
// wait for the timeout specified
Thread.Sleep(minutes);
// now we can set the lock so another team can play
_groundsLock.Set();
}
}
class Team
{
string teamName;
FootBallGround _ground;
public Team(string teamName, FootBallGround ground)
{
this.teamName = teamName;
this._ground = ground;
}
public bool PlayGame()
{
// this method returns true if the team has acquired the lock to the grounds
// otherwise it returns false and allows other teams to access the grounds
if (!_ground.Playing(this))
return false;
else
return true;
}
}
static void Main()
{
Team teamA = new Team();
Team teamB = new Team();
// select random value for GrandStatus from enum
RandomGroundStatus status = <Generate_Random_Status>;
// if the ground is wet no team is allowed to get the
// ground for 10 minutes.
if (status == RandomGroundStatus.Wet)
ThreadPool.QueueUserWorkItem(WaitForDryGround);
else
{
// if the ground is free, "Team A" locks the ground
// otherwise "Team B" locks the ground
if (status == RandomGroundStatus.Free)
{
if (!teamA.PlayGame())
teamB.PlayGame();
}
}
}
}
** Notes **
Use ManualResetEvent instead of lock and Monitor since we want direct control of when the state of the lock is pulsed to enable other threads to play a game of football.
Pass in a reference to the FootBallGrounds to each Team because each team will play on specific foot ball grounds and each football grounds could be occupied by another team
Pass in a reference to the current team playing on the FootBallGround because only one team can be playing on the grounds at a time.
Use ThreadPool.QueueUserWorkItem since it's more efficient at creating simple threads than us manually creating threads. Ideally we could use a Timer instance as well.