在.Net框架中 C# 实现多线程的同步方法详解

男娘i 2021-06-26 16:06 206阅读 0赞

本文主要描述在`C#`中线程同步的方法。线程的基本概念网上资料也很多就不再赘述了。直接接入主题，在多线程开发的应用中，线程同步是不可避免的。在`.Net`框架中，实现线程同步主要通过以下的几种方式来实现，在MSDN的线程指南中已经讲了几种，本文结合作者实际中用到的方式一起说明一下。

1.  维护自由锁(`InterLocked`)实现同步
2.  监视器（`Monitor`）和互斥锁（`lock`）
3.  读写锁（`ReadWriteLock`)
4.  系统内核对象
    
    1.  互斥(`Mutex`), 信号量(`Semaphore`), 事件(`AutoResetEvent/ManualResetEvent`)
    2.  线程池

除了以上的这些对象之外实现线程同步的还可以使用`Thread.Join`方法。这种方法比较简单，当你在第一个线程运行时想等待第二个线程执行结果，那么你可以让第二个线程`Join`进来就可以了。

## 自由锁(`InterLocked`) ##

对一个32位的整型数进行递增和递减操作来实现锁，有人会问为什么不用`++`或`--`来操作。因为在多线程中对锁进行操作必须是原子的，而`++`和`--`不具备这个能力。`InterLocked`类还提供了两个另外的函数`Exchange`, `CompareExchange`用于实现交换和比较交换。`Exchange`操作会将新值设置到变量中并返回变量的原来值: `int oVal = InterLocked.Exchange(ref val, 1)`。

## 监视器(`Monitor`) ##

在MSDN中对`Monitor`的描述是: `Monitor` 类通过向单个线程授予对象锁来控制对对象的访问。

`Monitor`类是一个静态类因此你不能通过实例化来得到类的对象。`Monitor`的成员可以查看MSDN，基本上`Monitor`的效果和`lock`是一样的，通过加锁操作`Enter`设置临界区，完成操作后使用`Exit`操作来释放对象锁。不过相对来说`Monitor`的功能更强，`Moniter`可以进行测试锁的状态，因此你可以控制对临界区的访问选择，等待or离开, 而且`Monitor`还可以在释放锁之前通知指定的对象，更重要的是使用`Monitor`可以跨越方法来操作。`Monitor`提供的方法很少就只有获取锁的方法`Enter`, `TryEnter`；释放锁的方法`Wait`, `Exit`；还有消息通知方法`Pulse`, `PulseAll`。经典的`Monitor`操作是这样的：

// 通监视器来创建临界区 
            static public void DelUser(string name)
            { 
                try
                { 
                    // 等待线程进入 
                    Monitor.Enter(Names);
                    Names.Remove(name);
                    Console.WriteLine("Del: {0}", Names.Count);
                    Monitor.Pulse(Names);
                }
                finally
                { 
                    // 释放对象锁 
                    Monitor.Exit(Names);
                }
            } 
        }

其中`Names`是一个`List`, 这里有一个小技巧，如果你想声明整个方法为线程同步可以使用方法属性：

// 通过属性设置整个方法为临界区 
            [MethodImpl(MethodImplOptions.Synchronized)] 
            static public void AddUser(string name) 
            {  
                Names.Add(name); 
                Console.WriteLine("Add: {0}",Names.Count); 
            }

对于`Monitor`的使用有一个方法是比较诡异的，那就是`Wait`方法。在MSDN中对`Wait`的描述是: 释放对象上的锁以便允许其他线程锁定和访问该对象。

这里提到的是先释放锁，那么显然我们需要先得到锁，否则调用`Wait`会出现异常，所以我们必须在`Wait`前面调用`Enter`方法或其他获取锁的方法，如`lock`，这点很重要。对应`Enter`方法，`Monitor`给出来另一种实现`TryEnter`。这两种方法的主要区别在于是否阻塞当前线程，`Enter`方法在获取不到锁时，会阻塞当前线程直到得到锁。不过缺点是如果永远得不到锁那么程序就会进入死锁状态。我们可以采用`Wait`来解决，在调用`Wait`时加入超时时限就可以。

if (Monitor.TryEnter(Names))
    { 
                    Monitor.Wait(Names, 1000); // !! 
                    Names.Remove(name); 
                    Console.WriteLine("Del: {0}", Names.Count);
                    Monitor.Pulse(Names); 
    }

## 互斥锁(`lock`) ##

`lock`关键字是实现线程同步的比较简单的方式，其实就是设置一个临界区。在`lock`之后的`{...}`区块为一个临界区，当进入临界区时加互斥锁，离开临界区时释放互斥锁。MSDN对`lock`关键字的描述是: `lock` 关键字可将语句块标记为临界区，方法是获取给定对象的互斥锁，执行语句，然后释放该锁。

具体例子如下:

static public void ThreadFunc(object name)
            { 
                string str = name as string;
                Random rand = new Random();
                int count = rand.Next(100, 200);
                for (int i = 0; i < count; i++)
                { 
                    lock (NumList)
                    { 
                        NumList.Add(i);
                        Console.WriteLine("{0} {1}", str, i);
                    }
                }
            }

对`lock`的使用有几点建议：对实例锁定`lock(this)`,对静态变量锁定`lock(typeof(val))`。`lock`的对象访问权限最好是`private`，否则会出现失去访问控制现象。

## 读写锁（`ReadWriteLock`) ##

读写锁的出现主要是在很多情况下，我们读资源的操作要多于写资源的操作。但是如果每次只对资源赋予一个线程的访问权限显然是低效的，读写锁的优势是同时可以有多个线程对同一资源进行读操作。因此在读操作比写操作多很多，并且写操作的时间很短的情况下使用读写锁是比较有效率的。读写锁是一个非静态类所以你在使用前需要先声明一个读写锁对象：

static private ReaderWriterLock _rwlock = new ReaderWriterLock();

读写锁是通过调用`AcquireReaderLock`，`ReleaseReaderLock`，`AcquireWriterLock`，`ReleaseWriterLock`来完成读锁和写锁控制的

static public void ReaderThread(int thrdId) 
    {  
                try 
                {  // 请求读锁，如果100ms超时退出 
                    _rwlock.AcquireReaderLock(10); 
                    try 
                    {  
                        int inx = _rand.Next(_list.Count); 
                        if (inx < _list.Count) 
                            Console.WriteLine("{0}thread {1}", thrdId, _list[inx]); 
                    } 
                    finally 
                    { 
                        _rwlock.ReleaseReaderLock(); 
                    } 
                } 
                catch (ApplicationException) // 如果请求读锁失败 
                {  
                    Console.WriteLine("{0}thread get reader lock out time!", thrdId); 
                } 
            } 
            static public void WriterThread() 
            {  
                try 
                { 
                    // 请求写锁 
                    _rwlock.AcquireWriterLock(100); 
                    try 
                    {  
                        string val = _rand.Next(200).ToString(); 
                        _list.Add(val); // 写入资源 
                        Console.WriteLine("writer thread has written {0}", val); 
                    } 
                    finally 
                    {  // 释放写锁 
                        _rwlock.ReleaseWriterLock(); 
                    } 
                } 
                catch (ApplicationException) 
                {  
                    Console.WriteLine("Get writer thread lock out time!"); 
                } 
    }

如果你想在读的时候插入写操作请使用`UpgradeToWriterLock`和`DowngradeFromWriterLock`来进行操作，而不是释放读锁。

static private void UpgradeAndDowngrade(int thrdId) 
            {  
                try 
                {  
                    _rwlock.AcquireReaderLock(10); 
                    try 
                    {  
                        try 
                        { 
                            // 提升读锁到写锁 
                            LockCookie lc = _rwlock.UpgradeToWriterLock(100);
                            try
                            { 
                                string val = _rand.Next(500).ToString();
    
                                _list.Add(val); Console.WriteLine
    ("Upgrade Thread{0} add {1}", thrdId, val); 
                            } 
                            finally
                            {  // 下降写锁 
                                _rwlock.DowngradeFromWriterLock(ref lc); 
                            } 
                        } 
                        catch (ApplicationException)
                        {  
                            Console.WriteLine("{0}thread upgrade reader lock failed!", thrdId); 
                        } 
                    } 
                    finally 
                    { 
                        // 释放原来的读锁 
                        _rwlock.ReleaseReaderLock();
                    }
                } 
                catch (ApplicationException) 
                {  
                    Console.WriteLine("{0}thread get reader lock out time!", thrdId);
                }
            }

这里有一点要注意的就是读锁和写锁的超时等待时间间隔的设置。通常情况下设置写锁的等待超时要比读锁的长，否则会经常发生写锁等待失败的情况。

## 系统内核对象 互斥对象（`Mutex`） ##

互斥对象的作用有点类似于监视器对象，确保一个代码块在同一时刻只有一个线程在执行。互斥对象和监视器对象的主要区别就是，互斥对象一般用于跨进程间的线程同步，而监视器对象则用于进程内的线程同步。互斥对象有两种：一种是命名互斥；另一种是匿名互斥。在跨进程中使用到的就是命名互斥，一个已命名的互斥就是一个系统级的互斥，它可以被其他进程所使用，只要在创建互斥时指定打开互斥的名称就可以。在`.Net`中互斥是通过`Mutex`类来实现。

其实对于`OpenExisting`函数有两个重载版本，

Mutex.OpenExisting (String)
    
    Mutex.OpenExisting (String, MutexRights)

对于默认的第一个函数其实是实现了第二个函数 `MutexRights.Synchronize|MutexRights.Modify`操作。

由于监视器的设计是基于`.Net`框架，而`Mutex`类是系统内核对象封装了`win32`的一个内核结构来实现互斥，并且互斥操作需要请求中断来完成，因此在进行进程内线程同步的时候性能上要比互斥要好。

典型的使用`Mutex`同步需要完成三个步骤的操作：  
1.打开或者创建一个`Mutex`实例；  
2.调用`WaitOne()`来请求互斥对象；  
3.最后调用`ReleaseMutex`来释放互斥对象。

static public void AddString(string str) 
            { 
                // 设置超时时限并在wait前退出非默认托管上下文 
                if (_mtx.WaitOne(1000, true))
                { 
                    _resource.Add(str); 
                    _mtx.ReleaseMutex(); 
                } 
            }

需要注意的是，`WaitOne`和`ReleaseMutex`必须成对出现，否则会导致进程死锁的发生，这时系统（.Net2.0）框架会抛出`AbandonedMutexException`异常。

## 信号量(`Semaphore`) ##

信号量就像一个夜总会：它有确切的容量，并被保镖控制。一旦满员，就没有人能再进入，其他人必须在外面排队。那么在里面离开一个人后，队头的人就可以进入。信号量的构造函数需要提供至少两个参数-现有的人数和最大的人数。

信号量的行为有点类似于`Mutex`或是`lock`，但是信号量没有拥有者。任意线程都可以调用`Release`来释放信号量而不像`Mutex`和`lock`那样需要线程得到资源才能释放。

class SemaphoreTest 
        { 
            static Semaphore s = new Semaphore(3, 3); // 当前值=3; 容量=3 
            static void Main() 
            { 
                for (int i = 0; i < 10; i++) 
                    new Thread(Go).Start(); 
            } 
            static void Go()
            { 
                while (true)
                { 
                    s.WaitOne();
                    Thread.Sleep(100); // 一次只有个线程能被处理 
                    s.Release(); 
                } 
            }
        }

## 事件(`ManualResetEvent`/`AutoResetEvent`) ##

### `AutoResetEvent` ###

一个`AutoResetEvent`象是一个"检票轮盘"：插入一张通行证然后让一个人通过。"auto"的意思就是这个"轮盘"自动关闭或者打开让某人通过。线程将在调用`WaitOne`后进行等待或者是阻塞，并且通过调用`Set`操作来插入线程。如果一堆线程调用了`WaitOne`操作，那么"轮盘"就会建立一个等待队列。一个通行证可以来自任意一个线程，换句话说任意一个线程都可以通过访问`AutoResetEvent`对象并调用`Set`来释放一个阻塞的线程。

如果在`Set`被调用的时候没有线程等待，那么句柄就会一直处于打开状态直到有线程调用了`WaitOne`操作。这种行为避免了竞争条件-当一个线程还没来得急释放而另一个线程就开始进入的情况。因此重复的调用`Set`操作一个"轮盘"哪怕是没有等待线程也不会一次性的让所有线程进入。

`WaitOne`操作接受一个超时参数-当发生等待超时的时候，这个方法会返回一个`false`。当已有一个线程在等待的时候，`WaitOne`操作可以指定等待还是退出当前同步上下文。`Reset`操作提供了关闭"轮盘"的操作。  
`AutoResetEvent`能够通过两个方法来创建:  
1.调用构造函数 `EventWaitHandle wh = new AutoResetEvent (false);` 如果`boolean`值为`true`，那么句柄的`Set`操作将在创建后自动被调用 ；  
2. 通过基类`EventWaitHandle`方式 `EventWaitHandle wh = new EventWaitHandle (false, EventResetMode.Auto);` `EventWaitHandle`构造函数允许创建一个`ManualResetEvent`。人们应该通过调用`Close`来释放一个`Wait Handle`在它不再使用的时候。当在应用程序的生存期内`Wait handle`继续被使用，那么如果遗漏了`Close`这步，在应用程序关闭的时候也会被自动释放。

class BasicWaitHandle 
        { 
            static EventWaitHandle wh = new AutoResetEvent(false);
            static void Main()
            { 
                new Thread(Waiter).Start();
                Thread.Sleep(1000); // 等待一会儿 
                wh.Set(); // 唤醒 
            } 
            static void Waiter()
            { 
                Console.WriteLine("Waiting...");
                wh.WaitOne(); // 等待唤醒 
                Console.WriteLine("Notified"); 
            }
        }

### `ManualResetEvent` ###

`ManualResetEvent`是`AutoResetEvent`的一个特例。它的不同之处在于在线程调用`WaitOne`后不会自动的重置状态。它的工作机制有点象是开关：调用`Set`打开并允许其他线程进行`WaitOne`；调用`Reset`关闭那么排队的线程就要等待，直到下一次打开。可以使用一个带`volatile`声明的`boolean`字段来模拟间断休眠 - 通过重复检测标志，然后休眠一小段时间。

`ManualResetEvent`常常被用于协助完成一个特殊的操作，或者让一个线程在开始工作前完成初始化。

## 线程池(`Thread Pooling`) ##

如果你的应用程序拥有大量的线程并花费大量的时间阻塞在一个`Wait Handle`上，那么你要考虑使用线程池(`Thead pooling`)来处理。线程池通过合并多个`Wait Handle`来节约等待的时间。当`Wait Handle`被激活时，使用线程池你需要注册一个`Wait Handle`到一个委托去执行。通过调用`ThreadPool.RegisterWaitForSingleObject`方法：

class Test 
        { 
            static ManualResetEvent starter = new ManualResetEvent(false); 
            public static void Main()
            { 
                ThreadPool.RegisterWaitForSingleObject(starter, Go, "hello", -1, true);
                Thread.Sleep(5000);
                Console.WriteLine("Signaling worker...");
                starter.Set(); 
                Console.ReadLine();
            }
            public static void Go(object data, bool timedOut) 
            { 
                Console.WriteLine("Started " + data); // Perform task... 
            }
        }

对于`Wait Handle`和委托，`RegisterWaitForSingleObject`接受一个"黑盒"对象并传递给你的委托（就像`ParameterizedThreadStart`），超时设置和`boolean`标志指示了关闭和循环的请求。所有进入池中的线程都被认为是后台线程，这就意味着它们不再由应用程序控制，而是由系统控制直到应用程序退出。

注意：如果这时候调用`Abort`操作，可能会发生意想不到的情况。

你也可以通过调用`QueueUserWorkItem`方法使用线程池，指定委托并立即被执行。这时你不能在多任务情况下保存共享线程，但是可以得到另外的好处：线程池会保持一个线程的总容量，当作业数超出容量时自动插入任务。

class Test 
        { 
            static object workerLocker = new object();
            static int runningWorkers = 100;
            public static void Main() 
            { 
                for (int i = 0; i < runningWorkers; i++) 
                { 
                    ThreadPool.QueueUserWorkItem(Go, i); 
                }
                Console.WriteLine("Waiting for threads to complete..."); 
                lock (workerLocker) 
                { 
                    while (runningWorkers > 0) 
                        Monitor.Wait(workerLocker);
                }
                Console.WriteLine("Complete!");
                Console.ReadLine(); 
            }
            public static void Go(object instance) 
            { 
                Console.WriteLine("Started: " + instance);
                Thread.Sleep(1000); 
                Console.WriteLine("Ended: " + instance); 
                lock (workerLocker)
                { 
                    runningWorkers--;
                    Monitor.Pulse(workerLocker);
                }
            }
        }

为了传递多个对象到目标方法，你必须定义一个客户对象并包含所有属性或通过调用异步的委托。如`Go`方法接受两参数：

ThreadPool.QueueUserWorkItem (delegate (object notUsed) {  Go (23,34); });

其他的方法可以使用异步委托。

--------------------

# .net多线程同步方式总结 #

在多线程开发中，共享对象的同步是经常遇到的问题，以下总结了C\#中线程同步的几种技术：

## 1，`InterLocked`原子操作 ##

Decrement(ref int location);递减1
    
    Add(ref int location1, int value);location1+value
    
    Increment(ref int location);递增1

## 2，`Mutex`互斥锁 ##

WaitOne(int timeout);等待获取锁
    
    ReleaseMutex();释放锁，记得一定要释放，否则永远被阻塞

## 3，`SemaphoreSlim`信号量 ##

SemaphoreSlim(int count);允许的并发线程数量
    
    Wait();等待
    
    Release();释放

## 4，`AutoRestEvent`自动重置时间(内核模式) ##

Set();从一个线程向另一个线程发送通知；
    
    WaitOne();等待通知

## 5，`ManaulResetEventSlim`手动重置时间（混合模式） ##

Wait();等待
    
    Set();通知
    
    Reset();重置

## 6，`CountDownEvent`计数事件 ##

CountdownEvent(int count);通知计数
    
    Signal();计数（线程完成一定调用）
    
    Wait();等待
    
    Dispose();释放

7，`Barrier`

Barrier(int participantCount, Action<Barrier> postPhaseAction);多个线程同步，回调Action
    
    SignalAndWait();执行回调

8，`ReaderWriterLockSlim`读写锁

EnterReadLock();获取读锁（可共享读）
    
    ExitReadLock();释放读锁
    
    EnterUpgradeableReadLock();获取读锁（可升级到写锁）;
    
    ExitUpgradeableReadLock();释放升级读锁
    
    EnterWriteLock();获取写锁（其他线程不可读写）
    
    ExitWriteLock();释放写锁

9，`SpinWait`自旋等待（混合模式）

SpinOnce();自旋