C# Thread 多线程 Monitor 锁 Producer And Consumer 生产者和消费者 经典模型

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace ConsoleApplication1
{
    //说明:
    //2个线程启动的时候抢夺CPU资源,于是产生了2种线程执行先后顺序的情况，不过好在我们
    //的程序能控制即使消费者优先抢到了CPU资源也要阻塞，直到生产者生产出1个_count值,
    //
    //以下仅仅说明该程序2个线程之间状态的转换，对于高手，请绕过说明。
    //1. Producer(生产者先获取_locker)
    //       Producer获取锁
    //       Consumer进入就绪队列
    //       Producer进入等待队列，释放锁
    //       Consumer获取锁
    //       Producer进入就绪队列
    //       Consumer进入等待队列，释放锁
    //       _count加1
    //       Console打印“生产者”
    //       Consumer进入就绪队列
    //       Producer释放锁
    //       Console打印“消费者”
    //       Producer进入就绪队列
    //       Consumer释放锁
    //       Producer再次进入for循环
    //
    //
    //2. Consumer(消费者先获取_locker)
    //       Consumer获取锁
    //       Producer进入就绪队列
    //       Consumer进入等待队列，释放锁
    //       Producer获取锁
    //       Consumer进入就绪队列
    //       Producer进入等待队列，释放锁
    //       Producer进入就绪队列
    //       Consumer释放锁
    //       _count加1
    //       Console打印“生产者”
    //       Consumer进入就绪队列
    //       Producer释放锁
    //       Consumer获取锁
    //       Producer进入就绪队列
    //       Consumer进入等待队列，释放锁
    //       Producer再次进入for循环
    //
    //注：本段代码摘自网络,原出处：
    //http://www.51testing.com/html/32/367232-857405.html
    class ThreadProcConsume
    {
        private int _count;
        private object _locker = new object();


        public ThreadProcConsume(int _count)
        {
            this._count = _count;
        }

        public void Run()
        {
            Thread tProducer = new Thread(new ThreadStart(Producer));
            Thread tConsumer = new Thread(new ThreadStart(Consumer));

            tProducer.Start();
            tConsumer.Start();
        }

        public void Producer()
        {
            for (int i = 0; i < 10; i++)
            {
                try
                {
                    //持有锁，进入线程，其他线程阻塞
                    Monitor.Enter(_locker);
                    //将等待队列中的线程添加到就绪队列
                    Monitor.Pulse(_locker);
                    //释放锁_locker, 将线程自身添加到等待队列
                    Monitor.Wait(_locker);

                    this._count++;

                    Console.WriteLine("生产者 " + _count.ToString());
                    
                    Monitor.Pulse(_locker);
                }
                finally
                {
                    //仅释放锁
                    Monitor.Exit(_locker);
                }
            }
        }

        public void Consumer()
        {
            try
            {
                Monitor.Enter(_locker);
                Monitor.Pulse(_locker);
                
                while (Monitor.Wait(_locker))
                {
                    if (this._count != 0)
                    {
                        Console.WriteLine("消费者 " + this._count.ToString());
                    }
                    Monitor.Pulse(_locker);
                    if (this._count == 10)
                    {
                        return;
                    }
                }
            }
            finally
            {
                Monitor.Exit(_locker);
            }
        }
    }
}

客户端代码：

using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            ThreadProcConsume tp = new ThreadProcConsume(0);
            tp.Run();

            Console.ReadKey();
        }
    }
}