如果不是逐字节生成和消耗，而是分块工作，您可能会获得更多的加速。在这种情况下，代码的“无锁”可能根本不重要——事实上，传统的锁定解决方案可能更可取。我会尝试证明。
在 C# 中给出了一个无锁、single 生产者、single 消费者、有界 队列。 （清单 A）
没有深奥的互锁操作，甚至没有显式的内存屏障。比方说，乍一看，它的速度和无锁一样快。不是吗？
现在让我们将其与锁定解决方案that Marc Gravell has given, here进行比较。
我们将使用在内核之间没有共享 L3 缓存的双 CPU 机器。
我们预计最多 2 倍的加速。 2 倍的加速确实意味着无锁解决方案在理论范围内表现理想。
为了给无锁代码创造一个理想的环境，我们甚至会使用here中的实用程序类来设置生产者和消费者线程的CPU亲和性。
测试的结果代码在（清单 B）中。
它正在生产约。在一个线程上消耗 10MBytes，而在另一个线程上消耗它。
队列大小固定为 32KBytes。如果已满，则生产者等待。
在我的机器上运行的典型测试如下所示：
LockFreeByteQueue：799 毫秒
字节队列：1843ms
无锁队列更快。哇，它的速度是原来的 2 倍以上！这是值得吹嘘的。 :)
让我们看看发生了什么。
Marc 的锁定队列就是这样做的。它锁定。它对每个字节都这样做。
我们真的需要锁定每个字节并逐字节推送数据吗？它肯定会以块的形式到达网络上（例如一些大约 1k 的数据包）。即使它真的是从内部源逐字节到达，生产者也可以轻松地将其打包成漂亮的块。
让我们这样做 - 不是逐字节生成和消耗，而是分块工作并将其他两个测试添加到微基准测试（清单 C，只需将其插入基准测试主体）。
现在典型的运行如下所示：
LockFreePageQueue：33 毫秒
页面队列：25 毫秒
现在，它们实际上都比原始无锁代码快 20 倍 - Marc's solution 添加了分块实际上比带有分块的无锁代码快！
我们没有采用会导致 2 倍加速的无锁结构，而是尝试了另一种解决方案，该解决方案可以很好地处理锁定并导致 20 倍（！）加速。
许多问题的关键不是避免锁定，而是避免共享和最小化锁定。在上述情况下，我们可以避免在字节复制期间共享。
我们可以在大部分时间处理私有结构，然后将单个指针排入队列，从而将共享空间和时间缩减为将单个指针插入队列中。
清单 A，一个无锁、单一生产者、单一消费者队列：
public class BoundedSingleProducerSingleConsumerQueue<T>
{
T[] queue;
volatile int tail;
volatile int head;
public BoundedSingleProducerSingleConsumerQueue(int capacity)
{
queue = new T[capacity + 1];
tail = head = 0;
}
public bool TryEnqueue(T item)
{
int newtail = (tail + 1) % queue.Length;
if (newtail == head) return false;
queue[tail] = item;
tail = newtail;
return true;
}
public bool TryDequeue(out T item)
{
item = default(T);
if (head == tail) return false;
item = queue[head];
queue[head] = default(T);
head = (head + 1) % queue.Length;
return true;
}
}
清单 B，微基准：
class Program
{
static void Main(string[] args)
{
for (int numtrials = 3; numtrials > 0; --numtrials)
{
using (ProcessorAffinity.BeginAffinity(0))
{
int pagesize = 1024 * 10;
int numpages = 1024;
int totalbytes = pagesize * numpages;
BoundedSingleProducerSingleConsumerQueue<byte> lockFreeByteQueue = new BoundedSingleProducerSingleConsumerQueue<byte>(1024 * 32);
Stopwatch sw = new Stopwatch();
sw.Start();
ThreadPool.QueueUserWorkItem(delegate(object state)
{
using (ProcessorAffinity.BeginAffinity(1))
{
for (int i = 0; i < totalbytes; i++)
{
while (!lockFreeByteQueue.TryEnqueue((byte)(i & 0xFF))) ;
}
}
});
for (int i = 0; i < totalbytes; i++)
{
byte tmp;
while (!lockFreeByteQueue.TryDequeue(out tmp)) ;
}
sw.Stop();
Console.WriteLine("LockFreeByteQueue: {0}ms", sw.ElapsedMilliseconds);
SizeQueue<byte> byteQueue = new SizeQueue<byte>(1024 * 32);
sw.Reset();
sw.Start();
ThreadPool.QueueUserWorkItem(delegate(object state)
{
using (ProcessorAffinity.BeginAffinity(1))
{
for (int i = 0; i < totalbytes; i++)
{
byteQueue.Enqueue((byte)(i & 0xFF));
}
}
});
for (int i = 0; i < totalbytes; i++)
{
byte tmp = byteQueue.Dequeue();
}
sw.Stop();
Console.WriteLine("ByteQueue: {0}ms", sw.ElapsedMilliseconds);
Console.ReadKey();
}
}
}
}
清单 C，分块测试：
BoundedSingleProducerSingleConsumerQueue<byte[]> lockfreePageQueue = new BoundedSingleProducerSingleConsumerQueue<byte[]>(32);
sw.Reset();
sw.Start();
ThreadPool.QueueUserWorkItem(delegate(object state)
{
using (ProcessorAffinity.BeginAffinity(1))
{
for (int i = 0; i < numpages; i++)
{
byte[] page = new byte[pagesize];
for (int j = 0; j < pagesize; j++)
{
page[j] = (byte)(i & 0xFF);
}
while (!lockfreePageQueue.TryEnqueue(page)) ;
}
}
});
for (int i = 0; i < numpages; i++)
{
byte[] page;
while (!lockfreePageQueue.TryDequeue(out page)) ;
for (int j = 0; j < pagesize; j++)
{
byte tmp = page[j];
}
}
sw.Stop();
Console.WriteLine("LockFreePageQueue: {0}ms", sw.ElapsedMilliseconds);
SizeQueue<byte[]> pageQueue = new SizeQueue<byte[]>(32);
ThreadPool.QueueUserWorkItem(delegate(object state)
{
using (ProcessorAffinity.BeginAffinity(1))
{
for (int i = 0; i < numpages; i++)
{
byte[] page = new byte[pagesize];
for (int j = 0; j < pagesize; j++)
{
page[j] = (byte)(i & 0xFF);
}
pageQueue.Enqueue(page);
}
}
});
sw.Reset();
sw.Start();
for (int i = 0; i < numpages; i++)
{
byte[] page = pageQueue.Dequeue();
for (int j = 0; j < pagesize; j++)
{
byte tmp = page[j];
}
}
sw.Stop();
Console.WriteLine("PageQueue: {0}ms", sw.ElapsedMilliseconds);