C# 线程资源同步方式总结(一)

在现代的程序开发中,资源的同步是一个比较重要的课题,在.Net中,对这部分有很丰富类库供我们使用,现在总结一下在各种情况下对资源同步的
机制。

     1.将字段声明为volatile
       
        当一个字段被声明为volatile时,CLR中一些管理代码和内存的内部机制将负责对字段进行同步,并且总能保证读取到的字段信息都为最新的值,被声明为
volatile的字段必须具备以下特征之一
         
        1.为引用类型
        2.一个指针(在不安全代码中)
        3.sbyte,byte,short,ushort,int,uint,char,float,bool
        4.一个使用底层类型的枚举类型

     2.使用System.Threading.Interlocked 类

         在许多增对整数的操作中,我们都比较容易忽视线程的问题,例如执行下列代码

         i = i + 1;

         实际上,上述代码分为3步骤
              1).  从内存中,读取i的值
              2).  将读取出来的值加1
              3).  将新的值写入内存中

         在单线程上,这个操作不会有任何问题,但是当i被多个线程访问时,问题就出现了,对i进行修改的线程,在上述的任何一部都有可能被其它读取线程打断,想象一下,
当操作线程执行完第二步,准备将新的值写入内存中时,此时其它读取线程获得了执行权,这时读取到的i的值并不是我们想要的,因此,这个操作不具备原子性,在.Net中,使用Interlocked类能确保操作的原子性,Interlocked类有以下的方法

          Increment
          Decrement
          Exchange
         
         上述的方法的参数都为带ref 标识的参数,因此我们说,这些方法保证了数据的原子性,在多线程中,涉及到整数的操作时,数据的原子性值得考虑,Interlocked的操作代码如下

     

            int i = 0;
            System.Threading.Interlocked.Increment(ref i);
            Console.WriteLine(i);
            System.Threading.Interlocked.Decrement(ref i);
            Console.WriteLine(i);
            System.Threading.Interlocked.Exchange(ref i, 100);
            Console.WriteLine(i);

          输出信息如下

          

       3.使用lock关键字
            
          地球人都知道,使用lock关键字可以获取一个对象的独占权,任何需要获取这个对象的操作的线程必须等待以获取该对象的线程释放独占权,lock提供了简单的同步资源的方法,与Java中的synchronized关键字类似。

          lock关键字的使用示例代码如下

object o = new object();
            lock (o)
            {
                Console.WriteLine("O");
            }

      4.使用System.Theading.Monitor类进行同步

          System.Threading.Monitor类提供了与lock类似的功能,不过与lock不同的是,它能更好的控制同步块,当调用了Monitor的Enter(Object o)方法时,会获取o的独占权,直到调用Exit(Object o)方法时,才会释放对o的独占权,可以多次调用Enter(Object o)方法,只需要调用同样次数的Exit(Object o)方法即可,Monitor类同时提供了TryEnter(Object o,[int])的一个重载方法,该方法尝试获取o对象的独占权,当获取独占权失败时,将返回false,查看如下代码

          

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;
namespace MonitorApplication
{
    class Program
    {
        private static object m_monitorObject = new object();
        static void Main(string[] args)
        {
            Thread thread = new Thread(Do);
            thread.Name = "Thread1";
            Thread thread2 = new Thread(Do);
            thread2.Name = "Thread2";
            thread.Start();
            thread2.Start();
            thread.Join();
            thread2.Join();

        }

        static void Do()
        {
            if (!Monitor.TryEnter(m_monitorObject))
            {
                Console.WriteLine("Can't visit Object " + Thread.CurrentThread.Name);
                return;
            }
            try
           {
                Monitor.Enter(m_monitorObject);
               Console.WriteLine("Enter Monitor " + Thread.CurrentThread.Name);
                Thread.Sleep(5000);
            }
            finally
            {
                Monitor.Exit(m_monitorObject);
            }
        }
    }
}

 当线程1获取了m_monitorObject对象独占权时,线程2尝试调用TryEnter(m_monitorObject),此时会由于无法获取独占权而返回false,输出信息如下



可以看到线程2无法获取到m_monitorObject的独占权,因此输出了一条错误信息.

Monitor类比lock类提供了一种更优秀的功能,考虑一下如下的场景

      1.当你进入某家餐馆时,发现餐馆里坐满了客人,但是你又不想换地方,因此,你选择等待。
      2.当餐馆内的服务员发现有空位置时,他通知前台的服务生,服务生给你安排了一个座位,于是你开始享受国际化的大餐。

使用Monitor类就可以实现如上的应用需求,在Monitor类中,提供了如下三个静态方法

       Monitor.Pulse(Object o)
       Monitor.PulseAll(Object o)
       Monitor.Wait(Object o ) // 重载函数

当调用Wait方法时,线程释放资源的独占锁,并且阻塞在wait方法直到另外的线程获取资源的独占锁后,更新资源信息并调用Pulse方法后返回。

我们模拟上述代码如下

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;
namespace MonitorApplication
{
    class Program
    {
        private static  object m_isFull = new object();
        static void Main(string[] args)
        {
            Thread thread = new Thread(HaveLunch);
            thread.Name = "HaveLunchThread";
            Thread thread2 = new Thread(SeatChange);
            thread2.Name = "SeatChangeThread";
            thread.Start();
            System.Threading.Thread.Sleep(2000);
            thread2.Start();
            thread.Join();
            thread2.Join();
        }

        private static void HaveLunch()
        {
            lock (m_isFull)
            {
                Console.WriteLine("Wati for seta");
                Monitor.Wait(m_isFull);
                Console.WriteLine("Have a good lunch!");
            }
        }

        private static void SeatChange()
        {
            lock (m_isFull)
            {
                Console.WriteLine("Seat was changed");
                Monitor.Pulse(m_isFull);
            }
        }
    }
}

输出信息如下



可见,使用Monitor,我们能实现一种唤醒式的机制,相信在实际应用中有不少类似的场景。