private static Mutex mutex = null;  //設(shè)為Static成員，是為了在整個(gè)程序生命周期內(nèi)持有Mutex

static void Main()
{
    bool firstInstance;

    mutex = new Mutex(true, @"Global\MutexSampleApp", out firstInstance);
    try
    {
        if (firstInstance)
        {
            Console.WriteLine("我們是第一個(gè)實(shí)例！");
        }
        else
        {
            Console.WriteLine("警告，已有實(shí)例運(yùn)行！");
            return;
        }
    }
    finally
    {
        //只有第一個(gè)實(shí)例獲得控制權(quán)，因此只有在這種情況下才需要ReleaseMutex，否則會(huì)引發(fā)異常。
        if (firstInstance)
        {
            mutex.ReleaseMutex();
        }
        mutex.Close();
        mutex = null;
    }
}

Semaphore sem = new Semaphore(0, 1);

private static Semaphore _pool;

private static int _padding;

public static void Main()
{
    _pool = new Semaphore(0, 3);

    for (int i = 1; i <= 5; i++)//創(chuàng)建并啟動(dòng)五個(gè)線程。
    {
        Thread t = new Thread(new ParameterizedThreadStart(Worker));

        t.Start(i);// 啟動(dòng)線程，傳遞數(shù)字。
    }

    Thread.Sleep(500);

    Console.WriteLine("Main thread calls Release(3).");
    _pool.Release(3);//調(diào)用Release(3)會(huì)使信號(hào)量計(jì)數(shù)回其最大值，并允許等待的線程進(jìn)入信號(hào)量，一次最多三個(gè)。

    Console.WriteLine("Main thread exits.");
}

private static void Worker(object num)
{
    Console.WriteLine("Thread {0} begins " + "and waits for the semaphore.", num);
    _pool.WaitOne();

    //填充間隔，使輸出更加有序。
    int padding = Interlocked.Add(ref _padding, 100);

    Console.WriteLine("Thread {0} enters the semaphore.", num);

    Thread.Sleep(1000 + padding);

    Console.WriteLine("Thread {0} releases the semaphore.", num);
    Console.WriteLine("Thread {0} previous semaphore count: {1}", num, _pool.Release());
}

// 表示對(duì)象的先進(jìn)先出集合
Queue oQueue = new Queue();
try
{
    // 現(xiàn)在 oQueue 對(duì)象只能被當(dāng)前線程操縱了
    Monitor.Enter(oQueue);
 
    // do something......
}
catch
{
 
}
finally
{
    // 釋放鎖 
    Monitor.Exit(oQueue);
}

/// <summary>
/// 測(cè)試類
/// </summary>
public class MonitorSample
{
    public static void Main(String[] args)
    {
        // 一個(gè)標(biāo)志位，如果是 0 表示程序沒有出錯(cuò)，如果是 1 表明有錯(cuò)誤發(fā)生
        int result = 0;

        // 下面使用 cell 初始化 CellProd 和 CellCons 兩個(gè)類，生產(chǎn)和消費(fèi)次數(shù)均為 20 次 
        Cell cell = new Cell();
        CellProd prod = new CellProd(cell, 20);
        CellCons cons = new CellCons(cell, 20);
        Thread producer = new Thread(new ThreadStart(prod.ThreadRun));
        Thread consumer = new Thread(new ThreadStart(cons.ThreadRun));

        // 生產(chǎn)者線程和消費(fèi)者線程都已經(jīng)被創(chuàng)建，但是沒有開始執(zhí)行 
        try
        {
            producer.Start();
            consumer.Start();
            producer.Join();
            consumer.Join();//等待這兩個(gè)線程結(jié)束才往下執(zhí)行
            Console.ReadLine();
        }
        catch (ThreadStateException e)
        {
            // 當(dāng)線程因?yàn)樗帬顟B(tài)的原因而不能執(zhí)行被請(qǐng)求的操作 
            Console.WriteLine(e);
            result = 1;
        }
        catch (ThreadInterruptedException e)
        {
            // 當(dāng)線程在等待狀態(tài)的時(shí)候中止 
            Console.WriteLine(e);
            result = 1;
        }
        // 盡管 Main() 函數(shù)沒有返回值，但下面這條語句可以向父進(jìn)程返回執(zhí)行結(jié)果 
        Environment.ExitCode = result;
    }
}

/// <summary>
/// 生產(chǎn)者
/// </summary>
public class CellProd
{
    /// <summary>
    /// 被操作的 Cell 對(duì)象
    /// </summary>
    Cell cell;

    /// <summary>
    /// 生產(chǎn)者生產(chǎn)次數(shù)，初始化為 1 
    /// </summary>
    int quantity = 1;

    public CellProd(Cell box, int request)
    {
        cell = box;
        quantity = request;
    }

    public void ThreadRun()
    {
        for (int looper = 1; looper <= quantity; looper++)
        {
            // 生產(chǎn)者向操作對(duì)象寫入信息 
            cell.WriteToCell(looper);
        }
    }
}

/// <summary>
/// 消費(fèi)者
/// </summary>
public class CellCons
{
    Cell cell;
    int quantity = 1;

    public CellCons(Cell box, int request)
    {
        cell = box;
        quantity = request;
    }

    public void ThreadRun()
    {
        int valReturned;
        for (int looper = 1; looper <= quantity; looper++)
        {
            valReturned = cell.ReadFromCell(); // 消費(fèi)者從操作對(duì)象中讀取信息 
        }
    }
}

/// <summary>
/// 被操作的對(duì)象
/// </summary>
public class Cell
{
    /// <summary>
    /// Cell 對(duì)象里的內(nèi)容
    /// </summary>
    int cellContents;

    /// <summary>
    /// 狀態(tài)標(biāo)志: 為 true 時(shí)可以讀取，為 false 則正在寫入
    /// </summary>
    bool readerFlag = false;

    public int ReadFromCell()
    {
        lock (this)
        {
            if (!readerFlag)
            {
                try
                {
                    // 等待 WriteToCell 方法中調(diào)用 Monitor.Pulse()方法 
                    Monitor.Wait(this);
                }
                catch (SynchronizationLockException e)
                {
                    Console.WriteLine(e);
                }
                catch (ThreadInterruptedException e)
                {
                    Console.WriteLine(e);
                }
            }

            // 開始消費(fèi)行為
            Console.WriteLine("Consume: {0}", cellContents);
            Console.WriteLine();

            // 重置 readerFlag 標(biāo)志，表示消費(fèi)行為已經(jīng)完成 
            readerFlag = false;

            Monitor.Pulse(this);// 通知 WriteToCell()方法（該方法在另外一個(gè)線程中執(zhí)行，等待中）
        }
        return cellContents;
    }

    public void WriteToCell(int n)
    {
        lock (this)
        {
            if (readerFlag)
            {
                try
                {
                    Monitor.Wait(this);
                }
                catch (SynchronizationLockException e)
                {
                    // 當(dāng)同步方法（指Monitor類除Enter之外的方法）在非同步的代碼區(qū)被調(diào)用 
                    Console.WriteLine(e);
                }
                catch (ThreadInterruptedException e)
                {
                    // 當(dāng)線程在等待狀態(tài)的時(shí)候中止 
                    Console.WriteLine(e);
                }
            }
            cellContents = n;
            Console.WriteLine("Produce: {0}", cellContents);
            readerFlag = true;
            Monitor.Pulse(this); // 通知另外一個(gè)線程中正在等待的 ReadFromCell() 方法 
        }
    }
}

static internal Thread[] threads = new Thread[10];
public static void Main()
{
    Account acc = new Account(100);
    for (int i = 0; i < 10; i++)
    {
        Thread t = new Thread(new ThreadStart(acc.DoTransactions));
        threads[i] = t;
        threads[i].Name = i.ToString();
        threads[i].Start(); //10個(gè)線程同時(shí)啟動(dòng)
    }
}

internal class Account
{
    int balance;internal Account(int initial)
    {
        balance = initial;
    }

    internal void DoTransactions()
    {
        for (int i = 0; i < 100; i++)
        {
            int amount = new Random().Next(-100, 100);

            lock (this)
            {
                Console.WriteLine("當(dāng)前線程:" + Thread.CurrentThread.Name + " 余額:" + balance.ToString() + " 數(shù)量:" + amount);
                if (balance >= amount)
                {
                    Thread.Sleep(5);
                    balance = balance - amount;
                }
                else
                {
                    Console.WriteLine("當(dāng)前線程:" + Thread.CurrentThread.Name + " 不能交易，余額不足:" + balance.ToString());
                    return;
                }
            }
        }
    }
}

void Main()
{
    TestIncrementUnSafe();
    TestIncrementSafe();
}

private int value1 = 0;
public void TestIncrementUnSafe()
{
    for (int i = 0; i < 5; i++)
    {
        Thread t = new Thread(IncrementValue1);
        t.Name = "t1 " + i;
        t.Start();
    }
    Thread.Sleep(2000);
    //value maybe 500000
    Console.WriteLine("value1 = " + value1);
}
private void IncrementValue1()
{
    for (int i = 0; i < 1000000; i++)
    {
        value1++;
    }
}


private int value2 = 0;
public void TestIncrementSafe()
{
    for (int i = 0; i < 5; i++)
    {
        Thread t = new Thread(IncrementValue2);
        t.Name = "t2 " + i;
        t.Start();
    }
    Thread.Sleep(2000);
    //value should be 500000
    Console.WriteLine("value2 = " + value2);
}

private void IncrementValue2()
{
    for (int i = 0; i < 1000000; i++)
    {
        Interlocked.Increment(ref value2);
    }
}

void Main()
{
    TestExchangeSafe();
    TestCompareExchangeSafe();
}
private int value3 = 0;
public void TestExchangeSafe()
{
    for (int i = 0; i < 5; i++)
    {
        Thread t = new Thread(ExchangeValue3);
        t.Name = "t2 " + i;
        t.Start();
    }
    Thread.Sleep(2000);
    //value should be 83
    Console.WriteLine("value3 = " + value3);
}
private void ExchangeValue3()
{
    Interlocked.Exchange(ref value3, 83);
}


private int value4 = 0;
public void TestCompareExchangeSafe()
{
    for (int i = 0; i < 5; i++)
    {
        Thread t = new Thread(ExchangeValue3);
        t.Name = "t2 " + i;
        t.Start();
    }
    Thread.Sleep(2000);
    //value should be 99 or 0
    Console.WriteLine("value4 = " + value4);
}
private void ExchangeValue4()
{
    //if value4=0, set value4=99
    Interlocked.CompareExchange(ref value4, 99, 0);
}