C# 多线程详解 Part.04（Lock、Monitor、生产与消费）

internalclassAccount

{

intbalance;

Randomr=newRandom();

internalAccount(intinitial)

{

balance=initial;

}

internalvoidWithdraw(intamount)

{

if(balance<0)

{

thrownewException("NegativeBalance");

}

lock(this)

{

//下面的代码保证在当前线程修改balance的值完成之前

//不会有其他线程也执行这段代码来修改balance的值

//因此，balance的值是不可能小于0的

Console.WriteLine("CurrentThread:"+Thread.CurrentThread.Name

+"balance:"+balance.ToString()+"amount:"+amount);

//如果没有lock关键字的保护，那么可能在执行完if的条件判断之后

//另外一个线程却执行了balance=balance-amount修改了balance的值

//而这个修改对这个线程是不可见的，所以可能导致这时if的条件已经不成立了

//但是，这个线程却继续执行balance=balance-amount，所以导致balance可能小于0

//去除lock块可以看出效果,程序会抛出异常

if(balance>=amount)

{

Thread.Sleep(5);

balance=balance-amount;

}

Console.WriteLine("CurrentThread:"+Thread.CurrentThread.Name

+"balance:"+balance.ToString()+"amount:"+amount);

}

}

internalvoidDoTransactions()

{

for(inti=0;i<100;i++)

{

Withdraw(r.Next(-50,100));

}

}

}

internalclassTest

{

staticinternalThread[]threads=newThread[10];

publicstaticvoidMain()

{

Accountacc=newAccount(0);

for(inti=0;i<10;i++)

{

Threadt=newThread(newThreadStart(acc.DoTransactions));

threads[i]=t;

threads[i].Name=i.ToString();

}

for(inti=0;i<10;i++)

{

threads[i].Start();

}

Console.ReadLine();

}

}

Monitor

//表示对象的先进先出集合

QueueoQueue=newQueue();

try

{

//现在oQueue对象只能被当前线程操纵了

Monitor.Enter(oQueue);

//dosomething......

}

catch

{

}

finally

{

//释放锁

Monitor.Exit(oQueue);

}

生产与消费

///<summary>

///被操作的对象

///</summary>

publicclassCell

{

///<summary>

///Cell对象里的内容

///</summary>

intcellContents;

///<summary>

///状态标志:为true时可以读取，为false则正在写入

///</summary>

boolreaderFlag=false;

publicintReadFromCell()

{

lock(this)

{

if(!readerFlag)

{

try

{

//等待WriteToCell方法中调用Monitor.Pulse()方法

Monitor.Wait(this);

}

catch(SynchronizationLockExceptione)

{

Console.WriteLine(e);

}

catch(ThreadInterruptedExceptione)

{

Console.WriteLine(e);

}

}

//开始消费行为

Console.WriteLine("Consume:{0}",cellContents);

Console.WriteLine();

//重置readerFlag标志，表示消费行为已经完成

readerFlag=false;

//通知WriteToCell()方法（该方法在另外一个线程中执行，等待中）

Monitor.Pulse(this);

}

returncellContents;

}

publicvoidWriteToCell(intn)

{

lock(this)

{

if(readerFlag)

{

try

{

Monitor.Wait(this);

}

catch(SynchronizationLockExceptione)

{

//当同步方法（指Monitor类除Enter之外的方法）在非同步的代码区被调用

Console.WriteLine(e);

}

catch(ThreadInterruptedExceptione)

{

//当线程在等待状态的时候中止

Console.WriteLine(e);

}

}

cellContents=n;

Console.WriteLine("Produce:{0}",cellContents);

readerFlag=true;

Monitor.Pulse(this);//通知另外一个线程中正在等待的ReadFromCell()方法

}

}

}

///<summary>

///生产者

///</summary>

publicclassCellProd

{

///<summary>

///被操作的Cell对象

///</summary>

Cellcell;

///<summary>

///生产者生产次数，初始化为1

///</summary>

intquantity=1;

publicCellProd(Cellbox,intrequest)

{

cell=box;

quantity=request;

}

publicvoidThreadRun()

{

for(intlooper=1;looper<=quantity;looper++)

{

//生产者向操作对象写入信息

cell.WriteToCell(looper);

}

}

}

///<summary>

///消费者

///</summary>

publicclassCellCons

{

Cellcell;

intquantity=1;

publicCellCons(Cellbox,intrequest)

{

cell=box;

quantity=request;

}

publicvoidThreadRun()

{

intvalReturned;

for(intlooper=1;looper<=quantity;looper++)

{

valReturned=cell.ReadFromCell();//消费者从操作对象中读取信息

}

}

}

///<summary>

///测试类

///</summary>

publicclassMonitorSample

{

publicstaticvoidMain(String[]args)

{

//一个标志位，如果是0表示程序没有出错，如果是1表明有错误发生

intresult=0;

//下面使用cell初始化CellProd和CellCons两个类，生产和消费次数均为20次

Cellcell=newCell();

CellProdprod=newCellProd(cell,20);

CellConscons=newCellCons(cell,20);

Threadproducer=newThread(newThreadStart(prod.ThreadRun));

Threadconsumer=newThread(newThreadStart(cons.ThreadRun));

//生产者线程和消费者线程都已经被创建，但是没有开始执行

try

{

producer.Start();

consumer.Start();

producer.Join();

consumer.Join();

Console.ReadLine();

}

catch(ThreadStateExceptione)

{

//当线程因为所处状态的原因而不能执行被请求的操作

Console.WriteLine(e);

result=1;

}

catch(ThreadInterruptedExceptione)

{

//当线程在等待状态的时候中止

Console.WriteLine(e);

result=1;

}

//尽管Main()函数没有返回值，但下面这条语句可以向父进程返回执行结果

Environment.ExitCode=result;

}

}