.NET 线程学习笔记二

  

互斥锁：

    //互斥锁是一个互斥的同步对象，这意味着在同一个时间有且仅有一个线程可以获取它。互斥锁适用于下列情况：

    //一个共享资源每次只能被一个线程使用。例如：考虑一个由多个进程共享的日志文件，任意时刻只能有一个进程对
    //该文件执行写入操作。互斥锁是解决此类问题的最佳同步工具。
    //互斥锁由System.Threading.Mutex类支持。该类有多个构造函数，其中最常用的两个是：
    //publi Mutex()
    //publi Mutex(bool owned)
    //第一个版本创建一个处于未获取状态的互斥锁。
    //在第二个版本中，如果owned为true,互斥锁的初始状态就是被主调线程所获取，否则处于未获取状态。
    //要获取一个互斥锁，应当调用互斥锁上的WaitOne()方法。该方法继承于System.Threading.WaitHandle
    //下面是它的最简单形式：
    //public bool WaitOne();
    //它将处于等待状态知道所调用的互斥锁可以被获取。因此该方法将阻塞主线程直到指定的互斥锁可用。该方法总是返回true.
    //如果代码不再需要拥有互斥锁，可以调用下面的ReleaseMutex()方法来释放它：
    //public void ReleaseMutex();
    //在互斥锁上调用该方法将使得互斥锁被释放，从而允许该互斥锁被另一个线程所获取。
    //要使用互斥锁来同步对共享资源的访问，需要使用WaitOne()和ReleaseMutex如下面的代码所示。

    //Mutex myMtx = new Mutex();
    //myMtx.WaitOne();
    //myMtx.ReleaseMutex();

    //在调用WaitOne()方法是，线程的执行将挂起直到获取互斥锁。在调用ReleaseMutex方法时，互斥锁将被释放，从而另一个线程可以获取它。
    //通过这种方法，共享资源可以被限制为每次只允许一个线程访问。

  

public class ShardRes
    {
        public static int Count = 0;
        public static Mutex Mtx = new Mutex();
    }

    class IncThread
    {
        int num;
        public Thread Thrd;
        public IncThread(string name, int n)
        {
            Thrd = new Thread(new ThreadStart(this.Run));
            num = n;
            Thrd.Name = name;
            Thrd.Start();
        }
        void Run()
        {
            Console.WriteLine(Thrd.Name + " is waiting for the mutex");
            ShardRes.Mtx.WaitOne();
            Console.WriteLine(Thrd.Name + " acquires the mutex.");
            do
            {
                Thread.Sleep(500);
                ShardRes.Count++;
                Console.WriteLine("In " + Thrd.Name + ",ShardRes.Count is" + ShardRes.Count);
                num--;
            }
            while (num > 0);
            Console.WriteLine(Thrd.Name + " releases the mutex.");
            ShardRes.Mtx.ReleaseMutex();
        }
    }

    public class DecThread
    {
        int num;
        public Thread Thrd;
        public DecThread(string name, int n)
        {
            Thrd = new Thread(new ThreadStart(this.Run));
            num = n;
            Thrd.Name = name;
            Thrd.Start();
        }

        public void Run()
        {
            Console.WriteLine(Thrd.Name + " is waiting for the mutex");

            ShardRes.Mtx.WaitOne();

            do
            {

                Thread.Sleep(500);
                ShardRes.Count--;
                Console.WriteLine("In " + Thrd.Name + ",SharedRes.count is " + ShardRes.Count);
                num--;
            } while (num > 0);

            Console.WriteLine(Thrd.Name + " releases the mutex.");

            ShardRes.Mtx.ReleaseMutex();
        }

    }

    class ThreadFive
    {
        public static void Main(string[] arg)
        {
            Console.WriteLine("ok");
            IncThread mt1 = new IncThread("Increment Thread", 5);
            Thread.Sleep(1);
            DecThread mt2 = new DecThread("Decrement Thread", 5);
            mt1.Thrd.Join();
            mt2.Thrd.Join();
            Console.Read();
        }
    }

信号量：

 //信号量类似于互斥锁，但它可以允许多个线程同时访问一个共享资源。因此在同步一个资源集合的时候，信号量就显得非常有用。
    //信号量通过一个计数器来控制对共享资源的访问。如果计数器大于0，那么就iu允许访问。如果计数器等于0，就拒绝访问。计数
    //器累计的是“许可证”的个数。因此，为了访问某个资源，线程将阻塞直到得到一个许可证。

    //信号量特别使用于下列情况：一个由“组(group)”或者"池(pool)"构成的共享资源。例如一个网络连接的集合，其中每一个连接
    //都可以用于通信，这就是一个资源池。需要网络连接的线程并不关心它获取的是哪一个网络连接。在这种情况下，信号量提供了
    //一种方便的机制来管理对连接的访问。
    //信号量是由System.Threading.Semaphore实现的。它有多个构造函数，最简单形式为:
    //public Semaphore(int initial,int max)
    //其中，initial指定了信号量许可证计数器的初始值，它指定可用的许可证数目。计数器的最大值在max中传递。max地表了信号量
    //最多拥有的许可证数目.initial的值指定了初始情况下有多少个许可证可用。


    //获取信号量使用  WaitOne()
    //不再需要使用信号量使用Release()方法释放。

    //注意：
    //线程在调用Release()之前可以多次调用WaitOne().但是，在释放许可证之前，WaitOne()的调用次数必须和Release()的调用次数一致。
    //或者，也可以调用Release(int)形式，传入WaitOne()的调用次数。

    class ThreadSix
    {
        public Thread Thr;

        static Semaphore sem = new Semaphore(2, 2);

        public ThreadSix(string name)
        {
            Thr = new Thread(this.Run);
            Thr.Name = name;
            Thr.Start();
        }

        public void Run()
        {
            Console.WriteLine(Thr.Name + " is waiting for permit");

            sem.WaitOne();

            Console.WriteLine(Thr.Name + " is acquires for permit");

            for (char ch = 'A'; ch < 'D'; ch++)
            {
                Console.WriteLine(Thr.Name + " : " + ch + " ");
                Thread.Sleep(500);
            }

            Console.WriteLine(Thr.Name + " releases a permit.");

            sem.Release();
        }
    }

    public class SemaphoreDemo
    {
        static void Main(string[] arg)
        {
            ThreadSix t1 = new ThreadSix("one");
            ThreadSix t2 = new ThreadSix("two");
            ThreadSix t3 = new ThreadSix("three");

            t1.Thr.Join();
            t2.Thr.Join();
            t3.Thr.Join();

            Console.Read();
        }
    }

  //使用事件实现同步。
    //同步事件有两种类型：ManualResetEvent(手工重置) AutoResetEvent(自动重置)
    //事件处理非常简单。对于ManualResetEvent,其处理过程处理如下：等待某个事件
    //的线程简单的代表该事件的事件对象上调用WaitOne();如果事件对象处于已发出
    //信号状态，WaitOne将立即返回。它将挂起主调线程直到事件发出信号。在另一个线程执行事件之后，该线程通过调用
    //Set()来把事件对象置于已发出信号状态,对WaitOne()的调用将返回，并且第一个线程恢复执行。
    //调用Reset()将该事件重置为未发出信号状态。

    public class ThreadSeven
    {
        public Thread Thrd;
        ManualResetEvent mre;

        public ThreadSeven(string name, ManualResetEvent evt)
        {
            Thrd = new Thread(this.Run);
            Thrd.Name = name;
            mre = evt;
            Thrd.Start();
        }
        public void Run()
        {
            Console.WriteLine("Inside thread " + Thrd.Name);
            for (int i = 0; i < 5; i++)
            {
                Console.WriteLine(Thrd.Name);
                Thread.Sleep(500);
            }

            Console.WriteLine(Thrd.Name + " Done!");

           mre.Set();
        }
    }

    class ManualEventDemo
    {
        static void Main()
        {
            ManualResetEvent mre = new ManualResetEvent(false);

            ThreadSeven mt1 = new ThreadSeven("Event Thread 1", mre);

            Console.WriteLine("Main thread is waiting first event.");

            mre.WaitOne();
          
            Console.WriteLine("Main thread received first event.");

            mre.Reset();

            mt1 = new ThreadSeven("Event Thread 2", mre);

            mre.WaitOne();

            Console.WriteLine("Main Thread received second event.");

            Console.Read();
        }
    }