多重影分身——C#中多线程的使用二(争抢共享资源)
只要服务器承受得了,我们可以开任意个线程同时工作以提高效率,然而
两个线程争抢资源可能导致数据混乱。
例如:
public class MyFood { public static int Last { get; set; } public MyFood() { Last = 500; } public void EatFood() { int foods = Last; Thread.Sleep(1000); Last = foods - 1; Console.WriteLine(Last); } public void EatMuchFood() { int foods = Last; Thread.Sleep(3000); Last = foods - 10; Console.WriteLine(Last); } }
这里定义了个MyFood类,里面有个静态变量Last,存储剩余的食物。然后用构造函数假设初始有500的食物。
两个方法,分别是吃一个食物和吃10个食物,用Thread.Sleep()模拟吃东西需要花费时间。
OK,现在开始吃东西了:
MyFood e = new MyFood (); Thread th1 = new Thread(new ThreadStart(e.EatFood)); Thread th2 = new Thread(new ThreadStart(e.EatMuchFood)); th1.Start(); //499 th1.Join(); //这里等待第一个线程结束,再往后面走 th2.Start(); //489 Console.ReadKey();
没有任何问题,吃完第一个食物花费1秒钟,剩余499个。然后花费3秒钟吃10个食物,剩余489个。
假如我们不加th1.Join(), 那就是正常情况下的多线程,看看会发生什么:
MyFood e = new MyFood (); Thread th1 = new Thread(new ThreadStart(e.EatFood)); Thread th2 = new Thread(new ThreadStart(e.EatMuchFood)); th1.Start(); //499 th2.Start(); //490 Console.ReadKey();
可以看到两次输出分别是499和490,这里就有问题了。
EatFood方法,取出剩余Last后休息了1秒,然后再把-1后的数字赋值给Last。恰好,在这1秒期间,我们的th2进来调用EatMuchFood方法了,它也是先取总数,而这个总数却是EatFood方法还没有-1的总数,于是它取到的是500而不是499.
这就是问题发生的原因。
那么在对待总数这种共享资源上,同一时间我们希望只有一个线程来访问(这样才能确保数据正确),其中一个解决方案就是Lock
Lock
public class MyFood { private static readonly object lockHelper = new object(); public static int Last { get; set; } public MyFood() { Last = 500; } public void EatFood() { lock (lockHelper) { int foods = Last; Thread.Sleep(1000); Last = foods - 1; } Console.WriteLine(Last); } public void EatMuchFood() { lock (lockHelper) { int foods = Last; Thread.Sleep(3000); Last = foods - 10; } Console.WriteLine(Last); } }
这里添加了一个静态只读私有变量叫做lockHelper,然后修改了两个吃东西的方法,加了对lockHelper的锁定。
这样每次执行的时候,会判断lockHelper是否被锁定了,如果没有,就进入lock代码块把lockHelper锁定,并且执行其中的代码。出了lock代码块会自动释放锁。
这样就能保证在修改Last的时候,一次只有一个线程了。
本例中直接用lock(this)就行,this代表MyFood e 这个类的实例。
Monitor
Monitor是一个静态类,无法被实例化,有两个常用方法:
Monitor.Enter(object); 锁定传入对象保证只由当前线程操作。
Monitor.Exit(object); 释放被锁定的对象。
lock(obj) 的本质就是调用Monitor。
当我们锁定的是实例时,可能会导致多个实例间互斥不能实现:
public class MyFood { private static readonly object lockHelper = new object(); public static int Last { get; set; } public MyFood() { Last = 500; } public void EatFood() { Monitor.Enter(this);int foods = Last; Thread.Sleep(1000); Last = foods - 1;
Monitor.Exit(this); Console.WriteLine(Last); } } static void Main(string[] args) { MyFood e = new MyFood(); MyFood f = new MyFood(); Thread th1 = new Thread(new ThreadStart(e.EatFood)); Thread th2 = new Thread(new ThreadStart(f.EatFood)); th1.Start(); //499 th2.Start(); //499 Console.ReadKey(); }
因为我们锁定的是this,而this指向了不同的实例。
解决方法是锁定this的类型或者静态只读私有变量,即lock(typeof(this)) 或者 lock(lockHelper)
最好不要锁定string。
Monitor.Wait(obj) 和 Monitor.Pulse(obj)
这两个方法都是写在Monitor.Enter(obj)和Monitor.Pulse(obj)中间的。
Monitor.Wait(obj) ,用于在锁定对象之后,暂时释放锁,这样可以让其他线程也能访问。此时,它在等待其他Monitor.Pulse(obj)的通知,一旦收到,就继续往下执行。
Monitor.Pulse(obj), 用于告诉其他线程:我事忙完了,等我Monitor.Exit(obj)了,你们就接着弄吧
例子:
public class MyFood { private static readonly object lockHelper = new object(); public static int Last { get; set; } public MyFood() { Last = 500; } public void EatFood() { Monitor.Enter(lockHelper); //锁定lockHelper int foods = Last; Thread.Sleep(1000); Last = foods - 1; Console.WriteLine("第一个线程,剩余:" + Last); Monitor.Wait(lockHelper); //将该线程暂停,并释放锁允许其他线程访问
//等到了Monitor.Pulse(obj)和Monitor.Exit(obj)的信号,就继续往下执行 Monitor.Exit(lockHelper);
Console.WriteLine("第一个线程,等第二个执行完后剩余:" + Last); } public void EatMuchFood() { Monitor.Enter(lockHelper); //锁定对象 int foods = Last; Thread.Sleep(3000); Last = foods - 10; Monitor.Pulse(lockHelper); //通知其他线程,我忙完了,等我Monitor.Exit(obj)了,你们就继续吧 Monitor.Exit(lockHelper); //释放锁 Console.WriteLine("第二个线程,剩余:" + Last); } } class Program { static void Main(string[] args) { MyFood m = new MyFood(); Thread th1 = new Thread(new ThreadStart(m.EatFood)); Thread th2 = new Thread(new ThreadStart(m.EatMuchFood)); th1.Start(); th2.Start(); Console.ReadKey(); } }
这里输出结果为:
第一个线程,剩余:499
第二个线程,剩余:489
第一个线程,等第二个执行完后剩余:489