C# 生产者与消费者模式

情景：一个线程不断获取数据，另一个线程不断处理这些数据。

常规方法：数据列表加锁，两个线程获取锁，拿到操作权；类似代码如下：（不推荐）

  static void Main(string[] args)
        {
          lockClass l = new lockClass();
            for (int i = 0; i < 1000000; i++)
            {
                l.Equeue(i.ToString());

            }
       }

public class lockClass
    {
        Queue<string> currentQueue = new Queue<string>(10000000);//当前要插入数据的队列
        static readonly object objlock = new object();
        FileStream f = new FileStream("D://1.txt", FileMode.Create, FileAccess.Write, FileShare.None);
        StreamWriter writer;
        public lockClass()
        {
            writer = new StreamWriter(f);
            var backgroundWorker = new BackgroundWorker();
            backgroundWorker.DoWork += backgroundWorker_DoWork;
            backgroundWorker.RunWorkerAsync();
        }
        void backgroundWorker_DoWork(object sender, DoWorkEventArgs e)
        {
            while (true)
            {
                lock (objlock)
                {
                    if (currentQueue.Count > 0)
                    {
                        var item = currentQueue.Dequeue();
                        Console.WriteLine(item);
                        writer.WriteLine(item);

                    }

                }

            }
        }

        public void Equeue(string item)
        {
            lock (objlock)
            {

                currentQueue.Enqueue(item);

            }
        }

    }

　　方法2：双缓存队列处理，意思就是说，用两个队列，一个队列用于获取数据，另一个队列用于操作数据，通过信号量来处理线程调度，来取消“锁”带来的资源切换浪费，参考代码如下：

  static void Main(string[] args)
        {
var test = new DoubleBufferedQueue();
            for (int i = 0; i < 1000000; i++)
            {
                test.Equeue(i.ToString());

            }
}

public class DoubleBufferedQueue
    {
       public readonly Queue<string> Queue1 = new Queue<string>(10000000);
       public readonly Queue<string> Queue2 = new Queue<string>(10000000);
       private readonly ManualResetEvent lock1 = new ManualResetEvent(true);//一开始可以执行
       private readonly ManualResetEvent lock2 = new ManualResetEvent(false);
       private readonly AutoResetEvent _autoReset = new AutoResetEvent(true);
       private volatile Queue<string> currentQueue = new Queue<string>(10000000);//当前要插入数据的队列
       FileStream f = new FileStream("D://1.txt", FileMode.Create, FileAccess.Write, FileShare.None);
       StreamWriter writer;
       public DoubleBufferedQueue()
       {
           writer = new StreamWriter(f);
           currentQueue = Queue1;
           var backgroundWorker = new BackgroundWorker();
           backgroundWorker.DoWork += backgroundWorker_DoWork;
           backgroundWorker.RunWorkerAsync();
       }

       void backgroundWorker_DoWork(object sender, DoWorkEventArgs e)
       {
           while (true)
           {
               this._autoReset.WaitOne();//没有成员入队列时不进行其他操作；
               this.lock2.Reset();
               this.lock1.WaitOne();
               var readQueue = currentQueue;
               currentQueue = (currentQueue == Queue1) ? Queue2 : Queue1;
               this.lock2.Set();
               writeToConsonle(currentQueue);

           }
       }

       void writeToConsonle(Queue<string> readQueue)
       {

           while (readQueue.Count > 0)
           {
              var item= readQueue.Dequeue();
              Console.WriteLine(item);
              writer.WriteLine(item);
           }
       }

       public void Equeue(string item)
       {
           this.lock2.WaitOne();
           this.lock1.Reset();
           currentQueue.Enqueue(item);
           lock1.Set();
           _autoReset.Set();
       }

    }

　　方法3：用微软提供的BlockingCollection（线程安全的，可阻塞的资源的），个人理解就是资源安全的队列，并且当没有操作的时候（队列空闲的时候）不耗费资源，个人觉得和方法2原理类似（推荐使用）

 static void Main(string[] args)
        {

   var block = new blockingCollectionClass();
            for (int i = 0; i < 10000; i++)
            {

                block.Add(i.ToString());

            }
           Console.ReadKey();
}

public class blockingCollectionClass
    {
        BlockingCollection<string> blockingCollection = new BlockingCollection<string>();
        FileStream f = new FileStream("D://1.txt", FileMode.Create, FileAccess.Write, FileShare.None);
        StreamWriter writer;
        public void Add(string Item)
        {
            blockingCollection.Add(Item);
        }

        public blockingCollectionClass()
        {
            writer = new StreamWriter(f);
            var backgroundWorker = new BackgroundWorker();
            backgroundWorker.DoWork += backgroundWorker_DoWork;
            backgroundWorker.RunWorkerAsync();
        }

        void backgroundWorker_DoWork(object sender, DoWorkEventArgs e)
        {
            foreach (string value in blockingCollection.GetConsumingEnumerable())
            {
                Console.WriteLine(value);
                writer.WriteLine(value);
            }
        }

    }

　　情景2：秒杀活动、抢票等活动时，并发性很高，导致服务器阻塞，用户请求丢失；

策略1：可以采用以上队列的形式处理服务器高并发问题，所有的请求先加入队列，排队，后台线程来处理队列里面的请求；

策略2：够建一个队列容器，接收请求的线程从容器中取一个空的对列，当队列填满后，放回到容器中，再次从容器中取一个空队列；处理线程需要从容器中取出非空的队列，处理完队列为空，放回到容器去；从容器中取放队列需要加锁。如果要保证处理的顺序，容器可以选队列（放队列的队列）；