【原】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：够建一个队列容器，接收请求的线程从容器中取一个空的对列，当队列填满后，放回到容器中，再次从容器中取一个空队列；处理线程需要从容器中取出非空的队列，处理完队列为空，放回到容器去；从容器中取放队列需要加锁。如果要保证处理的顺序，容器可以选队列（放队列的队列）；