C#多线程同步

在编写多线程程序时无可避免会碰到线程的同步问题。什么是线程的同步呢？

举个例子：假如在一个公司里面有一个变量记录某人T的工资count=100，有两个主管A和B（即工作线程）在早一些时候拿了这个变量的值回去 ，过了一段时间A主管将T的工资加了5块，并存回count变量，而B主管将T的工资减去3块，并存回count变量。好了，本来T君可以得到102块的工资的，现在就变成98块了。这就是线程同步要解决的问题。

在.Net的某些对象里面，在读取里面的数据的同时还可以修改数据，这类的对象就是“线程安全”。但对于自己编写的代码段而言，就必须使用线程同步技术来保证数据的完整性和正确性了。

有几个规律： 1、假如一个对象（或变量）不会同时被多个其他线程访问，那么这个对象是不需使用线程同步的。 2、假如虽然有多个线程同时访问一个对象，但他们所访问的数据或方法并不相同（不交叉），那这种情况也不需使用线程同步。 例如上例中的那个公司里面假如有 T 和 Q 两个人，但他们的工资分别是由 A 和 B 主管的，那么这个工资的处理就不需要线程同步了。 3、假如一个对象会同时被多个其他线程访问，一般只需为这个对象添加线程同步的代码，而其他线程是不需添加额外代码的。

在C#里面用于实现线程同步的常用类有如下几类

1、Mutex类（互斥器），Monitor类，lock方法

2、ManualResetEvent类，AutoResetEvent类（这两个都是由EventWaitHandle类派生出来的）

3、ReaderWriterLock类

同一类的作用都差不多：其中 第一类的作用是：用来保护某段代码在执行的时候以独占的方式执行，这时假如有第二个线程想访问这个对象时就会被暂停。一直等到独占的 代码执行为止。就好比一堆人同时上一个公共厕所一样，使用这个方法就可以解决文章一开始时提出的问题：主管A要处理T君的工资之前，先lock一下T君，然后取出目前的count值，处理完之后再解除T君的锁定。假如主管B在主管A处理工资时也想取出count值，那么它只能是一直地等待A处理完之后才能继续。使用这个方法的一个缺点就是会降低程序的效率。本来是一个多个线程的操作，一旦碰到lock的语句时，那么这些线程只要排队处理，形同一个单线程操作。

下面举个例子说明一下这三个方法的使用： 假定有一个Tools类，里面一个int变量，还有Add和Delete方法，其中Add方法会使int变量的值增加，Delete方法使int变量值减少：

        public class Tools
        {
            private int count = ;
            public void Add(int n)
            {
                count += n;
            }

            public void Delete(int n)
            {
                count -= n;
            }
        } 

在多个线程同时访问这段代码时，因为一个语句会被编译器编译成多个指令，所以会可能出现这种情况：但某个线程调用Add方法时，这时的count值为 100，而正当要加上n的时候，另外一个线程调用了Delete，它要减去m，结果count加上了n，然后又在原先count=100的值的情况
下减掉了m，最后的结果是count被减去了m,而没有加上n。很明显Add方法和Delete方法是不能同时被调用的，所以必须进行线程同步处理。简单的方法是用lock语句：

        public class Tools
        {
            private object abcde = new object();
            private int count = ;

            public void Add(int n)
            {
                lock (abcde)
                {
                    count += n;
                }
            }

            public void Delete(int n)
            {
                lock (abcde)
                {
                    count -= n;
                }
            }
        } 

其中abcde是一个private级的内部变量，它不表示任何的意义，只是作为一种“令牌”的角色。 当执行Add方法中的lock(abcde)方法时，这个令牌就在Add方法的手中了，假如这时有第二个线程也想拿这个令牌，没门，惟有等待。一旦第一 个lock语句的花括号范围结束之后，这时令牌就被释放了，同时会迅速落到第二个线程的手中，并且排除其他后来的人。

使用Monitor类的方法大致一样：

        public class Tools
        {
            private object abcde = new object();
            private int count = ;

            public void Add(int n)
            {
                Monitor.Enter(abcde);
                count += n;
                Monitor.Exit(abcde);
            }

            public void Delete(int n)
            {
                Monitor.Enter(abcde);
                count -= n;
                Monitor.Exit(abcde);
            }
        }

Monitor的常用方法：Enter和Exit都是静态方法，作用跟lock语句的两个花括号一样。
而使用 Mutex 就不需声明一个“令牌”对象了，但要实例化之后才可以使用：

public class Tools
{
private Mutex mut = new Mutex();
private int count = ; 

public void Add(int n)
{
mut.WaitOne();
count+=n;
mut.ReleaseMutex();
} 

public void Delete(int n)
{
mut.WaitOne();
count-=n;
mut.ReleaseMutex();
}
} 

其中的WaitOne为等待方法，一直等到Mutex 被释放为止。初始的情况下，Mutex 对象是处于释放状态的，而一旦执行了WaitOne方法之后，它 就被捕捉了，一直到被调用了ReleaseMutex方法之后才被释放。

使用这三种方法都有一个要注重的问题，就是在独占代码段里面假如引起了异常，可能会使“令牌”对象不被释放，这样程序就会一直地死等下去了。 所以要在独占代码段里面处理好异常。例如下面这样的代码就是错误的：

      public void Add(int n)
      {
            try
            {
                mut.WaitOne();
                count += n;
                //....这里省略了N行代码
                //....这里是有可能引起异常的代码
                //....这里省略了N行代码
                mut.ReleaseMutex();
            }
            catch
            {
                Console.Writeline("error.");
            }
        } 

上面的代码一旦在try和catch里面发生了异常，那么Mutex就不能被释放，后面的程序就会卡死在WaitOne()一行，而应该改成这样：

       public void Add(int n)
        {
            mut.WaitOne();
            try
            {
                count += n;
                //....这里省略了N行代码
                //....这里是有可能引起异常的代码
                //....这里省略了N行代码
            }
            catch
            {
                Console.Writeline("error.");
            }
            mut.ReleaseMutex();
        } 

现在谈一下第二种： ManualResetEvent类，AutoResetEvent类

上面这两个类都是由EventWaitHandle类派生出来的，所以功能和调用方法都很相似。 这两个类常用于阻断某个线程的执行，然后在符合条件的情况下再恢复其执行。 举个例子，你想送花给一个MM，托了一个送花的小伙子送了过去，而你希望当MM收到花之后就立即打个电话过去告诉她。

但问题是你不知道花什么时候才送到MM的手里，打早了打迟了都不好，这时你可以使用ManualResetEvent对象帮忙。当委

托小伙子送花过去的时候，使用ManualResetEvent的WaitOne方法进行等待。当小伙子把花送到MM的手中时，再调用一下

ManualResetEvent的Set方法，你就可以准时地打电话过去了。 另外ManualResetEvent还有一个Reset方法，用来重新阻断调用者执行的，情况就好比你委托了这个小伙子送花给N个MM，

而又想准时地给这N个MM打电话的情况一样。

using System;
using System.Threading;

public class TestMain
{
    private static ManualResetEvent ent = new ManualResetEvent(false);

    public static void Main()
    {
        Boy sender = new Boy(ent);
        Thread th = new Thread(new ThreadStart(sender.SendFlower));
        th.Start();

        ent.WaitOne(); //等待工作
        Console.WriteLine("收到了吧，花是我送嘀:)");
        Console.ReadLine();
    }

}

public class Boy
{
    ManualResetEvent ent;

    public Boy(ManualResetEvent e)
    {
        ent = e;
    }

    public void SendFlower()
    {
        Console.WriteLine("正在送花的途中");
        for (int i = ; i < ; i++)
        {
            Thread.Sleep();
            Console.Write("..");
        }
        Console.WriteLine("\r\n花已经送到MM手中了,boss");

        ent.Set(); //通知阻塞程序
    }
}

而AutoResetEvent类故名思意，就是在每次Set完之后自动Reset。让执行程序重新进入阻塞状态。
即AutoResetEvent.Set() 相当于 ManualResetEvent.Set() 之后又立即 ManualResetEvent.Reset()，
其他的就没有什么不同的了。
举个送花给N个MM的例子：

using System;
using System.Threading;

public class TestMain
{
    private static AutoResetEvent ent = new AutoResetEvent(false);

    public static void Main()
    {
        Boy sender = new Boy(ent);

        for (int i = ; i < ; i++)
        {
            Thread th = new Thread(new ThreadStart(sender.SendFlower));
            th.Start();
            ent.WaitOne(); //等待工作
            Console.WriteLine("收到了吧，花是我送嘀:)\r\n\r\n");
        }

        Console.ReadLine();
    }

}

public class Boy
{
    AutoResetEvent ent;

    public Boy(AutoResetEvent e)
    {
        ent = e;
    }

    public void SendFlower()
    {
        Console.WriteLine("正在送花的途中");
        for (int i = ; i < ; i++)
        {
            Thread.Sleep();
            Console.Write("..");
        }
        Console.WriteLine("\r\n花已经送到MM手中了,boss");

        ent.Set(); //通知阻塞程序,这里的效果相当于 ManualResetEvent的Set()方法+Reset()方法 

    }
}

要注重的是ManualResetEvent和AutoResetEvent 的构造函数都有一个bool的参数，用这个参数可以指定初始情况下，同步对象的处于阻塞（设置为false）还是非阻塞（设置为true）的状态。
另外WaitOne方法也可以带两个参数：
WaitOne (int millisecondsTimeout,bool exitContext)
millisecondsTimeout：等待的毫秒数，或为 Timeout.Infinite (-1)，表示无限期等待。
exitContext：为 true，则等待之前先退出上下文的同步域（假如在同步上下文中），然后在稍后重新获取它；否则为false。
就是说，等待是可以加上一个期限的，假如等待的同步对象一直都不Set()的话，那么程序就会卡死，所以在WaitOne方法里面可以放置一个时间期限，单位是毫秒。