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

using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.ComponentModel;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

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

            }
            Console.ReadKey();
           
        }


    }


    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 += reader_backgroundWorker_DoWork;
            backgroundWorker.RunWorkerAsync();
        }

        void reader_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(readQueue);

            }
        }

        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原理类似（推荐使用）

 

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

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

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