NET中各种线程同步方法
在NET多线程开发中，有时候需要多个线程协调工作，完成这个步骤的过程称为“同步”。
使用同步的主要原因：
1.多个线程访问同一个共享资源。
2.多线程写入文件时保证只有一个线程使用文件资源。 3.由事件引发线程，线程等待事件，需要挂起线程。
NET中线程同步常见的几种方法：
1.lock
lock 确保当一个线程位于代码的临界区时，另一个线程不进入临界区。如果其他线程试图进入锁定的代码，则它将一直等待（即被阻止），直到该对象被释放。
lock的优点：简单易用，对象的同步几乎透明，轻量级。
使用lock需要注意：
锁定的对于应该是私有的，如果是公有的对象，可能出现超出控制范围的其它代码锁定该对象。
所以应该尽量避免使用lock(this)，不保证会有其他线程闯入破坏数据正确性。
一个lock(this)错误的示例：
class Program { static void Main(string[] args) { A a1 = new A(); A a2 = new A(); Thread T1 = new Thread(new ParameterizedThreadStart(a1.Test)); Thread T2 = new Thread(new ParameterizedThreadStart(a2.Test)); T1.Start(2); T2.Start(5); Console.Read(); } } public class A { public static Int32 Count = 2; public void Test(object i) { lock (this) { Console.WriteLine("Count={0}", Count); Count += (Int32)i; Thread.Sleep(1 * 1000); Console.WriteLine("i={0}，?Count+i={1}", i, Count); Console.WriteLine("--------------------------"); } } }
这里数据和我们期待的不相同。
这里lock锁定的是A的实例，当线程T1执行的时候，lock锁定了a1对象，所以线程t2可以执行a2对象的Test方法。
正确的写法：
public class A { private static object obj = new object(); public static Int32 Count = 2; public void Test(object i) { lock (obj) { Console.WriteLine("Count={0}", Count); Count += (Int32)i; Thread.Sleep(1 * 1000); Console.WriteLine("i={0}，?Count+i={1}", i, Count); Console.WriteLine("--------------------------"); } } }
这里的线程已经正常工作了，Count也正常的累加。
lock (obj)怎么错误了？
上面正常运行的程序稍微改动下！
class Program { static void Main(string[] args) { A a1 = new A(); A a2 = new A(); Thread T1 = new Thread(new ParameterizedThreadStart(a1.Test)); Thread T2 = new Thread(new ParameterizedThreadStart(a2.Test)); T1.Start(2); T2.Start(5); Console.Read(); } } public class A { private object obj = new object(); public static Int32 Count = 2; public void Test(object i) { lock (obj) { Console.WriteLine("Count={0}", Count); Count += (Int32)i; Thread.Sleep(1 * 1000); Console.WriteLine("i={0}，?Count+i={1}", i, Count); Console.WriteLine("--------------------------"); } } }
分析下：这里我们把
private static object obj = new object();
中的static去掉了，所以obj变成了私有的实例成员，a1，a2都有不同的obj实例，所以lock这里也就没什么作用了！
让lock不再错下去！
这里我们也不再把static写上去了，只需要把调用那里稍微改动下。
class Program { static void Main(string[] args) { A a1 = new A(); Thread T1 = new Thread(new ParameterizedThreadStart(a1.Test)); Thread T2 = new Thread(new ParameterizedThreadStart(a1.Test)); T1.Start(2); T2.Start(5); Console.Read(); } }
我们这里让a2对象去见马克思了，a1对象的Test调用了2次，这里lock锁定的obj都是a1的同一个私有对象obj，所以lock是起作用的！
Monitor
Monitor实现同步比lock复杂点，lock实际上是Monitor的简便方式，lock最终还是编译成Monitor。
不同处：
1.Monitor在使用的时候需要手动指定锁和手动释放手。
2.Monitor比lock多了几个实用的方法
public static bool Wait(object obj); public static void Pulse(object obj); public static void PulseAll(object obj);
Mointor同步实例：
class Program { static void Main(string[] args) { Int32[] nums = { 1, 2, 3, 4, 5 }; SumThread ST1 = new SumThread("Thread1"); SumThread ST2 = new SumThread("Thread2"); ST1.Run(nums); ST2.Run(nums); Console.Read(); } } public class SumThread { //注意这里私有静态SA是SumThread共有的，所以考虑同步问题 private static SumArray SA = new SumArray(); private Thread t; public SumThread(string ThreadName) { t = new Thread((object nums) => { Console.WriteLine("线程{0}开始执行...", t.Name); Int32 i = SA.GetSum((Int32[])nums); Console.WriteLine("线程{0}执行完毕，sum={1}", t.Name, i); }); t.Name = ThreadName; } public void Run(Int32[] nums) { t.Start(nums); } } public class SumArray { private Int32 sum; private object obj = new object(); public Int32 GetSum(Int32[] nums) { Monitor.Enter(obj); try { //初始化sum值，以免获取到其它线程的脏数据 sum = 0; foreach (Int32 num in nums) { sum += num; Console.WriteLine("当前线程是：{0},sum={1}", Thread.CurrentThread.Name, sum); Thread.Sleep(1 * 1000); } return sum; } catch (Exception e) { Console.WriteLine(e.Message); return 0; } finally { //很重要，千万不要忘记释放锁 Monitor.Exit(obj); } } }
这里线程之间和蔼可亲的执行着，没有去抢着计算。
试着把
Monitor.Enter(obj); Monitor.Exit(obj);
去掉，那么线程就不会这么听话了！
另外一种同步的写法
前面使用的同步方式并不是所有情况都适合的，假如我们调用的是第三方的组件，我们没有修改源码的权限，那么我们只有考虑下面这种同步的实现。
class Program { static void Main(string[] args) { Int32[] nums = { 1, 2, 3, 4, 5 }; SumThread ST1 = new SumThread("Thread1"); SumThread ST2 = new SumThread("Thread2"); ST1.Run(nums); ST2.Run(nums); Console.Read(); } } public class SumThread { //注意这里私有静态SA是SumThread共2有的，所以考虑同步问题 private static SumArray SA = new SumArray(); private Thread t; public SumThread(string ThreadName) { t = new Thread((object nums) => { Console.WriteLine("线程{0}开始执行...", t.Name); Monitor.Enter(SA); try { Int32 i = SA.GetSum((Int32[])nums); Console.WriteLine("线程{0}执行完毕，sum={1}", t.Name, i); } catch (Exception e) { Console.WriteLine(e.Message); } finally { //很重要，千万不要忘记释放锁 Monitor.Exit(SA); } }); t.Name = ThreadName; } public void Run(Int32[] nums) { t.Start(nums); } } public class SumArray { private Int32 sum; public Int32 GetSum(Int32[] nums) { //初始化sum值，以免获取到其它线程的脏数据 sum = 0; foreach (Int32 num in nums) { sum += num; Console.WriteLine("当前线程是：{0},sum={1}", Thread.CurrentThread.Name, sum); Thread.Sleep(1 * 1000); } return sum; } }
注意：这里锁定的是SA.GetSum()调用本身，不是方法内部代码，SA对象是私有的。
Monitor-线程通信
当线程T正在lock块执行，需要访问另外一个线程lock块中的资源R，这个时候如果T等待R可用，有可能会让线程进入死循环。
这里就可以使用线程通信，先让T暂时放弃对lock块中的控制，等R变得可用，那么就通知线程T恢复运行。
public static bool Wait(object obj); public static void Pulse(object obj); public static void PulseAll(object obj);
上面就是这里需要用的方法，属于Monitor。 Wait是让线程暂停，这个方法有个重写，多了一个参数指定暂停的毫秒数。
Pulse是唤醒线程。
时钟滴答例子：
class Program { static void Main(string[] args) { Clock C = new Clock(); C.RunClock(1); Console.Read(); } } public class Clock { private object obj = new object(); //开始运行时钟，输入运行分钟 public void RunClock(Int32 Minute) { Thread T1 = new Thread((object Minute1) => { Int32 m = Convert.ToInt32(Minute1) * 60 / 2; while (m > 0) { DI(true); m--; } }); Thread T2 = new Thread((object Minute1) => { Int32 m = Convert.ToInt32(Minute1) * 60 / 2; while (m > 0) { DA(true); m--; } }); T1.Start(Minute); T2.Start(Minute); } public void DI(bool run) { lock (obj) { Console.WriteLine("嘀"); Thread.Sleep(1000); Monitor.Pulse(obj);//执行完毕，唤醒其它线程 Monitor.Wait(obj);//进入暂停，移交执行权利，等待唤醒 } } public void DA(bool run) { lock (obj) { Console.WriteLine("嗒"); Thread.Sleep(1000); Monitor.Pulse(obj);//执行完毕，唤醒其它线程 Monitor.Wait(obj);//进入暂停，移交执行权利，等待唤醒 } } }
