.net4.0中的同步機制，是的，當出現了並行計算的時候，輕量級別的同步機制應運而生，在信號量這一塊

出現了一系列的輕量級，今天繼續介紹下面的3個信號量 CountdownEvent，SemaphoreSlim，ManualResetEventSlim。

一：CountdownEvent

這種采用信號狀態的同步基元非常適合在動態的fork,join的場景，它采用“信號計數”的方式，就比如這樣，一個麻將桌只能容納4個

人打麻將，如果後來的人也想搓一把碰碰運氣，那麽他必須等待直到麻將桌上的人走掉一位。好，這就是簡單的信號計數機制，從技術角

度上來說它是定義了最多能夠進入關鍵代碼的線程數。

但是CountdownEvent更牛X之處在於我們可以動態的改變“信號計數”的大小，比如一會兒能夠容納8個線程，一下又4個，一下又10個，

這樣做有什麽好處呢？還是承接上一篇文章所說的，比如一個任務需要加載1w條數據，那麽可能出現這種情況。

加載User表： 根據user表的數據量，我們需要開5個task。

加載Product表： 產品表數據相對比較多，計算之後需要開8個task。

加載order表： 由於我的網站訂單豐富，計算之後需要開12個task。

先前的文章也說了，我們需要協調task在多階段加載數據的同步問題，那麽如何應對這裏的5，8，12，幸好，CountdownEvent給我們提供了

可以動態修改的解決方案。

我們看到有兩個主要方法：Wait和Signal。每調用一次Signal相當於麻將桌上走了一個人，直到所有人都搓過麻將wait才給放行，這裏同樣要

註意也就是“超時“問題的存在性，尤其是在並行計算中，輕量級別給我們提供了”取消標記“的機制，這是在重量級別中不存在的，比如下面的

重載public bool Wait(int millisecondsTimeout, CancellationToken cancellationToken)，具體使用可以看前一篇文章的介紹。

//默認的容納大小為“硬件線程“數
static CountdownEvent cde = new CountdownEvent(Environment.ProcessorCount);

static void Main(string[] args)
{
    //加載User表需要5個任務
    var userTaskCount = 5;

    //重置信號
    cde.Reset(userTaskCount);

    for (int i = 0; i < userTaskCount; i++)
    {
        Task.Factory.StartNew((obj) 
 
=>
        {
            LoadUser(obj);
        }, i);
    }

    //等待所有任務執行完畢
    cde.Wait();

    Console.WriteLine("\nUser表數據全部加載完畢！\n");

    //加載product需要8個任務
    var productTaskCount = 8;

    //重置信號
    cde.Reset(productTaskCount);

    for (int i = 0; i < productTaskCount; i++)
    {
        Task.Factory.StartNew((obj) 
 
=>
        {
            LoadProduct(obj);
        }, i);
    }

    cde.Wait();

    Console.WriteLine("\nProduct表數據全部加載完畢！\n");

    //加載order需要12個任務
    var orderTaskCount = 12;

    //重置信號
    cde.Reset(orderTaskCount);

    for (int i = 0; i < orderTaskCount; i++)
    {
        Task.Factory.StartNew((obj) =>
        {
            LoadOrder(obj);
        }, i);
    }

    cde.Wait();

    Console.WriteLine("\nOrder表數據全部加載完畢！\n");

    Console.WriteLine("\n(*^__^*) 嘻嘻，恭喜你，數據全部加載完畢\n");

    Console.Read();
}

static void LoadUser(object obj)
{
    try
    {
        Console.WriteLine("當前任務:{0}正在加載User部分數據！", obj);
    }
    finally
    {
        cde.Signal();
    }
}

static void LoadProduct(object obj)
{
    try
    {
        Console.WriteLine("當前任務:{0}正在加載Product部分數據！", obj);
    }
    finally
    {
        cde.Signal();
    }
}

static void LoadOrder(object obj)
{
    try
    {
        Console.WriteLine("當前任務:{0}正在加載Order部分數據！", obj);
    }
    finally
    {
        cde.Signal();
    }
}

二：SemaphoreSlim

在.net 4.0之前，framework中有一個重量級的Semaphore，人家可以跨進程同步，咋輕量級不行，msdn對它的解釋為：限制可同時訪問

某一資源或資源池的線程數。關於它的重量級demo，我的上一個系列有演示，你也可以理解為CountdownEvent是 SemaphoreSlim的功能加

強版，好了，舉一個輕量級使用的例子。

static SemaphoreSlim slim = new SemaphoreSlim(Environment.ProcessorCount, 12);

static void Main(string[] args)
{
    for (int i = 0; i < 12; i++)
    {
        Task.Factory.StartNew((obj) =>
        {
            Run(obj);
        }, i);
    }

    Console.Read();
}

static void Run(object obj)
{
    slim.Wait();

    Console.WriteLine("當前時間:{0}任務 {1}已經進入。", DateTime.Now, obj);

    //這裏busy3s中
    Thread.Sleep(3000);

    slim.Release();
}

同樣，防止死鎖的情況，我們需要知道”超時和取消標記“的解決方案，像SemaphoreSlim這種定死的”線程請求範圍“，其實是降低了擴展性，

所以說，試水有風險，使用需謹慎，在覺得有必要的時候使用它。

三： ManualResetEventSlim

相信它的重量級別大家都知道是ManualReset，而這個輕量級別采用的是"自旋等待“+”內核等待“，也就是說先采用”自旋等待的方式“等待，

直到另一個任務調用set方法來釋放它。如果遲遲等不到釋放，那麽任務就會進入基於內核的等待，所以說如果我們知道等待的時間比較短，采

用輕量級的版本會具有更好的性能，原理大概就這樣，下面舉個小例子。

//2047：自旋的次數
 static ManualResetEventSlim mrs = new ManualResetEventSlim(false, 2047);

 static void Main(string[] args)
 {

     for (int i = 0; i < 12; i++)
     {
         Task.Factory.StartNew((obj) =>
         {
             Run(obj);
         }, i);
     }

     Console.WriteLine("當前時間:{0}我是主線程{1}，你們這些任務都等2s執行吧：\n",
     DateTime.Now,
     Thread.CurrentThread.ManagedThreadId);
     Thread.Sleep(2000);

     mrs.Set();
 }

 static void Run(object obj)
 {
     mrs.Wait();

     Console.WriteLine("當前時間:{0}任務 {1}已經進入。", DateTime.Now, obj);
 }

五、並行編程-信號量