我是CSharp和Threading的新手。
为了熟悉Monitor.Wait，Monitor.lock和Monitor.PulseAll，我构思了下面描述的场景。
“不同的球队正在为实践目的分享一个FootballGround。任何时候只有一个团队可以使用他们的练习场。一个团队可以使用地面练习30分钟。一旦时间达到25分钟，它应该发出信号通知其他人5分钟后地面即将释放的线程。当地面潮湿时（enum有三个值自由，分配，潮湿）没有任何队员可以锁定地面，所有人都应该等待10分钟“ 的
老实说，我不知道如何将描述转化为实际编码。根据我的理解，我设计了大纲。
namespace ThreadingSimulation
{
// A Random Activity can be picked up from this enum by a team
public enum RandomGroundStatus
{
free,
allotted,
Wet
}
class FootBallGround
{
public void Playing(object obj)
{
// Here the name of the team which is using the ground will be printed
// Once the time is reached to 25 minnutes the active thread acquired
// the lock will signal other threads
}
public void GroundCleaningInProgress(object obj)
{
// Ground cleaning is in progress all of you
// wait for 10 minutes
}
}
class Team
{
string teamName;
static void Main()
{
//select random value for GrandStatus from enum
// if the ground is wet no team is allowed to get the
// ground for 10 minutes
//if the ground is free "Team A" locks the ground
// otherwise "Team B" locks the ground
}
}
}
这里我不知道如何申请锁和signalls.kindly帮助我。
答案 0 :(得分：13)
实际上，您的方案并没有大量映射到lock - 但无论如何我们都会尝试;-p
我稍微调整了一下设置;代替：
这是代码;请注意，当使用理由时，他们没有锁定，因为这会阻止其他人加入Pulse的队列。
实际上，我们可以使用 lock完全所有（根本不使用Pulse），只需使用标准阻止行为。但是此示例显示Pulse和PulseAll用于在满足条件时重新激活线程。
using System;
using System.Threading;
interface IGroundUser
{
bool Invoke(); // do your stuff; return true to wake up *everyone*
// afterwards, else false
}
class Team : IGroundUser
{
private readonly string name;
public Team(string name) { this.name = name; }
public override string ToString() { return name; }
public bool Invoke()
{
Console.WriteLine(name + ": playing...");
Thread.Sleep(25 * 250);
Console.WriteLine(name + ": leaving...");
return false;
}
}
class Cleaner : IGroundUser
{
public override string ToString() {return "cleaner";}
public bool Invoke()
{
Console.WriteLine("cleaning in progress");
Thread.Sleep(10 * 250);
Console.WriteLine("cleaning complete");
return true;
}
}
class FootBallGround
{
static void Main()
{
var ground = new FootBallGround();
ThreadPool.QueueUserWorkItem(delegate { ground.UseGrounds(new Team("Team A")); });
ThreadPool.QueueUserWorkItem(delegate { ground.UseGrounds(new Team("Team B")); });
ThreadPool.QueueUserWorkItem(delegate { ground.UseGrounds(new Cleaner()); });
ThreadPool.QueueUserWorkItem(delegate { ground.UseGrounds(new Team("Team C")); });
ThreadPool.QueueUserWorkItem(delegate { ground.UseGrounds(new Team("Team D")); });
ThreadPool.QueueUserWorkItem(delegate { ground.UseGrounds(new Team("Team E")); });
Console.ReadLine();
}
bool busy;
private readonly object syncLock = new object();
public void UseGrounds(IGroundUser newUser)
{
// validate outside of lock
if (newUser == null) throw new ArgumentNullException("newUser");
// only need the lock when **changing** state
lock (syncLock)
{
while (busy)
{
Console.WriteLine(newUser + ": grounds are busy; waiting...");
Monitor.Wait(syncLock);
Console.WriteLine(newUser + ": got nudged");
}
busy = true; // we've got it!
}
// do this outside the lock, allowing other users to queue
// waiting for it to be free
bool wakeAll = newUser.Invoke();
// exit the game
lock (syncLock)
{
busy = false;
// wake up somebody (or everyone with PulseAll)
if (wakeAll) Monitor.PulseAll(syncLock);
else Monitor.Pulse(syncLock);
}
}
}
答案 1 :(得分：5)
使用锁定和mutithreaded applciations始终记住的重要一点是，锁定仅在 all 访问锁定资源的代码按照相同规则播放时才有效，即如果一个线程可以锁定资源，所有其他可以访问同一资源的线程都应该在访问该资源之前使用锁。
监控并锁定
lock关键字是Monitor类的Convenienve包装器。这意味着lock(obj)与Monitor.Enter(obj)相同（尽管Monitor具有添加的功能，如果它无法锁定对象，则会在一段时间后超时。）
脉冲事件和线程
当许多线程等待获取某些资源的锁定时，通过代码，您可以在所有者线程完成资源时发出信号。这称为信令或脉冲，可通过Monitor.Pulse，Monitor.PulseAll，ManualResetEvent.Set甚至AutoResetEvent.Set完成
因此，下面的足球示例将被编码为包含线程锁定，如下所示：
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();
}
}
}
}
**注意**
使用ManualResetEvent代替lock和Monitor，因为我们希望在锁定状态时直接控制以启用其他线程打一场足球比赛。
将FootBallGrounds的引用传递给每个Team，因为每支球队都会在特定的足球场上进行比赛，每个足球场都可能被另一支队伍占用
传递给FootBallGround上当前球队的参考，因为一次只有一支球队可以在球场上比赛。
使用ThreadPool.QueueUserWorkItem因为它比我们手动创建线程更有效地创建简单线程。理想情况下，我们也可以使用Timer实例。