NET多线程探索-互斥锁，信号量，事件(小新和拆弹部队友情演出)

mutex互斥锁-不准确的时钟

概念性的东西：
互斥锁是一个互斥的同步对象，一个时间只有一个线程可以获取它。
前一篇文章中的时钟程序我们这里用Mutex互斥锁来实现。
class Program
{
    static void Main(string[] args)
    {
        Clock C = new Clock();
        C.RunClock(1);
        Console.Read();
    }
}
public class Clock
{
    public Mutex Mtx = new Mutex();

    //开始运行时钟，输入运行分钟
    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(true);
        T2.Start(true);
    }

    public void DI(bool run)
    {
        Mtx.WaitOne();
        if (!run)
        {
            Mtx.ReleaseMutex();
            return;
        }
        else
        {
            Console.WriteLine("嘀");
            Thread.Sleep(1000);
            Mtx.ReleaseMutex();
        }
    }

    public void DA(bool run)
    {
        Mtx.WaitOne();
        if (!run)
        {
            Mtx.ReleaseMutex();
            return;
        }
        else
        {
            Console.WriteLine("嗒");
            Thread.Sleep(1000);
            Mtx.ReleaseMutex();
        }
    }
}

为什么会这样？貌似一切都是合理的！

这里我只发表下我的理解，还请个位园友自己认真分析下，毕竟我个人理解可能是错误的！
如果您发现我理解错了，请在评论指出，我好及时学习更早！

Monitor的时钟是使用了lock来锁定，lock最后也会被编译成为Monitor的Enter和Exit。
重点是Monitor在Pulse(obj)的时候已经就确定了另外一个等待obj被释放的线程拥有了执行权！
而Mutex在ReleaseMutex在释放锁定之后，当前线程和其他等待线程都执行WaitOne，导致了线程执行权的争夺！
随着程序的运行，线程之间的争夺激烈。
mutex互斥锁-杯具的拆弹手

下面用互斥锁实现个例子，一个炸弹，同时只能一个人拆弹，如果超过1个人就爆炸。
class Program
{
    static void Main(string[] args)
    {
        炸弹 b = new 炸弹();
        b.拆弹();
        b.拆弹();
        Console.Read();
    }
}
public class 炸弹
{
    private Int32 热度 = 0;
    public Mutex m = new Mutex();

    public void 拆弹()
    {
        Thread t = new Thread(炸弹内部);
        t.Start();
    }

    private void 炸弹内部()
    {
        m.WaitOne();
        热度++;
        Thread.Sleep(1000);
        if (热度>1)
        {
            Console.WriteLine("炸弹爆炸！拆弹手见马克思...");
            m.ReleaseMutex();
            return;
        }
        热度--;
        Console.WriteLine("炸弹安全拆除！拆弹手这个月奖金加倍...");
        m.ReleaseMutex();
    }
}

拆弹手很幸运，这个月奖金加倍了。如果把Mutex去掉，那么马克思就等着他们去聊天。
信号量-Semaphore

互斥锁和同步都是锁定一个资源，同时只让一个线程去操作。
对于可以允许限定数量线程执行的情况互斥锁就不适合了，这里就需要信号量。
信号量通过一个计数器来控制对共享资源的访问，如果计数器的闲置数大于0，那么就允许访问，如果=0就拒绝访问。

public Semaphore(int initialCount, int maximumCount);

initialCount:可以同时授予的信号量的初始请求数。
补充：Web开发 , ASP.Net ,