圆形无锁缓冲器

我正在设计一个系统，该系统连接到一个或多个数据提要流，并根据触发结果对数据进行一些分析。在典型的多线程生产者/消费者设置中，我将有多个生产者线程将数据放入队列中，并且有多个消费者线程读取数据，并且消费者只对最新数据点加n个点感兴趣。如果慢速使用者无法跟上生产者线程，则生产者线程将不得不阻塞，当然，当没有未处理的更新时，使用者线程也会阻塞。使用具有读取器/写入器锁定的典型并发队列会很好地工作，但是数据输入的速率可能很大，因此我想减少我的锁定开销，特别是为生产者减少写入器锁定。我认为我需要一个循环无锁缓冲区。

现在有两个问题：

1. 循环无锁缓冲区是否是答案？

2. 如果是这样，在我提出自己的建议之前，您知道任何适合我需要的公共实施方式吗？

始终欢迎实现循环无锁缓冲区的任何指针。

顺便说一句，在Linux上的C ++中执行此操作。

一些其他信息：

响应时间对我的系统至关重要。理想情况下，使用者线程希望尽快看到任何更新，因为额外的1毫秒延迟可能会使系统一文不值，甚至少很多。

我倾向于的设计思想是一个无半锁的循环缓冲区，在此缓冲区中，生产者线程将数据尽可能快地放入缓冲区中，我们将其称为缓冲区A的头，除非缓冲区已满，否则不要阻塞A与缓冲区Z的末尾相遇。使用者线程将分别持有两个指向循环缓冲区的指针P和P _n，其中P是线程的本地缓冲区头，而P _n是P之后的第_n个项目。每个使用者线程都将推进其P一旦完成当前P的处理，P _n和P _n就会以最慢的P _n前进到缓冲区指针Z的末尾。当P赶上A，这意味着不再有新的更新要处理时，使用者旋转并忙于等待A再次前进。如果使用者线程旋转时间过长，则可以使其进入睡眠状态并等待条件变量，但是我可以接受使用者占用CPU周期等待更新，因为这不会增加我的延迟（我将拥有更多的CPU内核）比线程）。想象一下，您有一个循环的轨道，而生产者在一群消费者的面前运行，关键是调整系统，以便生产者通常比消费者领先几步，而其中大多数操作可以使用无锁技术完成。我知道正确实现实现的细节并不容易...好吧，非常艰苦，这就是为什么我想在别人做些自己的事情之前先从别人的错误中学习。

在最近几年中，我对无锁数据结构进行了专门研究。我已经阅读了该领域的大多数论文（大约只有40篇，尽管只有10篇或15篇是真正的用途：-）

AFAIK，尚未发明无锁循环缓冲区。问题将是处理读者超越作家或反之亦然的复杂情况。

如果您至少有六个月没有学习无锁数据结构，请不要尝试自己编写一个。您将弄错了，直到您的代码在新平台上部署失败之后，错误才会对您显而易见。

我相信，但是您的要求可以解决。

您应该将无锁队列与无锁空闲列表配对。

空闲列表将为您提供预分配，从而消除了对无锁分配器的（非常昂贵的）需求；当空闲列表为空时，您可以通过立即从队列中将元素出队并使用该元素来复制循环缓冲区的行为。

（当然，在基于锁的循环缓冲区中，一旦获得了锁，获取元素就非常快-基本上只是指针取消引用-但在任何无锁算法中都不会得到它；它们通常必须走这完全不符合他们的做事方式；使自由列表弹出失败然后出队的开销与任何无锁算法都需要完成的工作量相当）。

迈克尔和斯科特在1996年开发了一个非常好的无锁队列。下面的链接将为您提供足够的详细信息，以查找其论文的PDF。迈克尔和斯科特（FIFO）

无锁的自由列表是最简单的无锁算法，实际上我认为我没有看到它的实际论文。

您想要的艺术术语是无锁队列。罗斯本西纳（Ross Bencina）提供了一组出色的笔记，其中包含指向代码和论文的链接。我最信任的作品是莫里斯·赫利希（Maurice Herlihy）（对美国人来说，他的名字叫“莫里斯”）。

如果缓冲区为空或已满，生产者或使用者将阻塞的要求建议您应使用带有信号量或条件变量的普通锁定数据结构，使生产者或使用者在数据可用之前阻塞。无锁代码通常不会在这种情况下阻塞-它旋转或放弃无法完成的操作，而不是使用OS进行阻塞。（如果您有足够的时间等到另一个线程产生或使用数据，那么为什么还要在锁上等待另一个线程完成更新数据结构的情况更糟？）

在（x86 / x64）Linux上，如果没有争用，则使用互斥锁的线程内同步相当便宜。专注于减少生产者和消费者需要抓住锁的时间。鉴于您已经说过您只关心最后记录的N个数据点，我认为循环缓冲区可以做到这一点。但是，我并不真正了解这与阻塞要求以及消费者实际使用（删除）他们读取的数据的想法是否相符。（您是否希望消费者仅查看最后N个数据点，而不是删除它们？您是否希望生产者不在乎消费者不能跟上，而只是覆盖旧数据？）

另外，正如Zan Lynx所评论的那样，当有大量数据输入时，您可以将数据聚合/缓冲成更大的块。您可以缓冲固定数量的点或在一定时间内接收到的所有数据。这意味着将减少同步操作。虽然确实会引入延迟，但是如果您不使用实时Linux，则无论如何都必须在一定程度上处理延迟。

boost库中的实现值得考虑。它易于使用且性能相当高。我编写了一个测试，并在四核i7笔记本电脑（8个线程）上运行了该程序，并每秒获得了约4M入队/出队操作。到目前为止尚未提及的另一种实现是位于http://moodycamel.com/blog/2014/detailed-design-of-a-lock-free-queue的MPMC队列。我已经在具有32个生产者和32个消费者的同一台笔记本电脑上对该实现进行了一些简单的测试。正如宣传的那样，增强型无锁队列更快。

正如大多数其他答案一样，无锁编程很难。大多数实现将很难检测到需要大量测试和调试才能解决的极端情况。这些通常是通过在代码中仔细放置内存屏障来解决的。您还将在许多学术文章中找到正确性的证明。我更喜欢使用蛮力工具测试这些实现。您计划在生产中使用的任何无锁算法都应使用http://research.microsoft.com/en-us/um/people/lamport/tla/tla.html之类的工具检查其正确性。

DDJ上有很多有关此的文章。为了表明这些知识可能有多么困难，这是对先前文章中的错误的更正。自己动手之前，请确保您理解错误）;;

我不是硬件内存模型和无锁数据结构的专家，我倾向于避免在我的项目中使用它们，而我选择传统的锁数据结构。

但是我最近注意到视频： 基于环形缓冲区的无锁SPSC队列

这基于交易系统使用的称为LMAX distruptor的开源高性能Java库：LMAX Distruptor

根据上面的介绍，您可以使头部和尾部指针原子化，并原子性地检查头部从后面抓尾或反之亦然的情况。

在下面，您可以看到一个非常基本的C ++ 11实现：

// USING SEQUENTIAL MEMORY
#include<thread>
#include<atomic>
#include <cinttypes>
using namespace std;

#define RING_BUFFER_SIZE 1024  // power of 2 for efficient %
class lockless_ring_buffer_spsc
{
    public :

        lockless_ring_buffer_spsc()
        {
            write.store(0);
            read.store(0);
        }

        bool try_push(int64_t val)
        {
            const auto current_tail = write.load();
            const auto next_tail = increment(current_tail);
            if (next_tail != read.load())
            {
                buffer[current_tail] = val;
                write.store(next_tail);
                return true;
            }

            return false;  
        }

        void push(int64_t val)
        {
            while( ! try_push(val) );
            // TODO: exponential backoff / sleep
        }

        bool try_pop(int64_t* pval)
        {
            auto currentHead = read.load();

            if (currentHead == write.load())
            {
                return false;
            }

            *pval = buffer[currentHead];
            read.store(increment(currentHead));

            return true;
        }

        int64_t pop()
        {
            int64_t ret;
            while( ! try_pop(&ret) );
            // TODO: exponential backoff / sleep
            return ret;
        }

    private :
        std::atomic<int64_t> write;
        std::atomic<int64_t> read;
        static const int64_t size = RING_BUFFER_SIZE;
        int64_t buffer[RING_BUFFER_SIZE];

        int64_t increment(int n)
        {
            return (n + 1) % size;
        }
};

int main (int argc, char** argv)
{
    lockless_ring_buffer_spsc queue;

    std::thread write_thread( [&] () {
             for(int i = 0; i<1000000; i++)
             {
                    queue.push(i);
             }
         }  // End of lambda expression
                                                );
    std::thread read_thread( [&] () {
             for(int i = 0; i<1000000; i++)
             {
                    queue.pop();
             }
         }  // End of lambda expression
                                                );
    write_thread.join();
    read_thread.join();

     return 0;
}

减少竞争的一种有用技术是将项目散列到多个队列中，并使每个使用者专用于“主题”。

对于您的消费者最近感兴趣的商品数量-您不想锁定整个队列并对其进行迭代以找到要覆盖的商品-只需发布N个元组中的商品，即所有N个最新商品即可。实现的奖励点是，生产者将在超时时阻塞整个队列（当消费者无法跟上时），从而更新其本地元组缓存-这样您就不会对数据源造成压力。

我会同意本文，并建议不要使用无锁数据结构。在无锁FIFO队列相对最近的一篇文章是这样，由同一作者（S）搜索更多的文件; 还有一篇关于Chalmers的关于无锁数据结构的博士学位论文（我丢失了链接）。但是，您没有说元素有多大-无锁数据结构仅对单词大小的项目有效地起作用，因此，如果元素大于机器单词（32或64），则必须动态分配元素位）。如果动态分配元素，则将（假定的，因为您没有分析程序，并且基本上在进行过早的优化）瓶颈转移到内存分配器，因此您需要无锁的内存分配器，例如Streamflow，并将其与您的应用程序集成。

Sutter的队列不是最理想的，他知道。多核编程的艺术是一个很好的参考，但是在存储模型上，不相信Java专家。Ross的链接不会给您确切的答案，因为它们的库在此类问题中，等等。

进行无锁编程会带来麻烦，除非您想在解决问题之前花大量时间进行显然过度设计的工作（从对问题的描述来看，这是“追求完美”的常见疯狂行为） '（在缓存一致性中）。这需要几年的时间，导致无法先解决问题，而后来又无法优化，这是一种常见疾病。

尽管这是一个老问题，但没有人提到DPDK的无锁环形缓冲区。这是一个高吞吐量的环形缓冲区，支持多个生产者和多个消费者。它还提供单一使用者和单一生产者模式，并且环形缓冲区在SPSC模式下无需等待。它是用C语言编写的，支持多种体系结构。

此外，它还支持批量和突发模式，可以在其中批量入队/出队物品。通过移动原子指针简单地保留空间，该设计让多个使用者或多个生产者同时写入队列。

只是为了完整性：OtlContainers中有经过良好测试的无锁循环缓冲区，但是它是用Delphi编写的（TOmniBaseBoundedQueue是循环缓冲区，TOmniBaseBoundedStack是有界堆栈）。同一单元（TOmniBaseQueue）中也有一个无限制的队列。动态无锁队列中描述了无界队列-正确执行。最后，在无锁队列中描述了有界队列（循环缓冲区）的最初实现！但此后代码已更新。

这是一个旧线程，但是由于尚未被提及-JUCE C ++框架中提供了一个无锁的，循环的，1个生产者-> 1个使用者，FIFO。

https://www.juce.com/doc/classAbstractFifo#details

请查看Disruptor（如何使用它），它是多个线程可以订阅的环形缓冲区：

这是我的方法：

• 将队列映射到数组
• 通过下一个读取和下一个写入索引保持状态
• 保持一个空的完整位向量

插入包括使用具有增量的CAS，并在下一次写入时翻转。有了插槽后，添加您的值，然后设置与其匹配的空/满位。

删除数据需要先检查该位，然后才能测试下溢，但除此之外，该操作与写入操作相同，但使用读取索引并清除空/满位。

被警告，

1. 我不是这些事情的专家
2. 当我使用原子ASM操作时，它们似乎非常慢，因此，如果最终使用了不止几个操作，则使用嵌入在插入/删除功能内的锁可能会更快。从理论上讲，单个原子操作要紧随其后（很少）非原子ASM操作可能比几个原子操作所完成的相同操作要快。但是要完成这项工作，需要手动或自动内联，因此这只是ASM的一小段。

你可以试试 lfqueue

简单易用，圆形设计无锁

int *ret;

lfqueue_t results;

lfqueue_init(&results);

/** Wrap This scope in multithread testing **/
int_data = (int*) malloc(sizeof(int));
assert(int_data != NULL);
*int_data = i++;
/*Enqueue*/
while (lfqueue_enq(&results, int_data) != 1) ;

/*Dequeue*/
while ( (ret = lfqueue_deq(&results)) == NULL);

// printf("%d\n", *(int*) ret );
free(ret);
/** End **/

lfqueue_clear(&results);

在某些情况下，不需要锁定即可防止出现竞争状况，尤其是当您只有一个生产者和消费者时。

考虑LDD3中的这一段：

如果精心实现，则在没有多个生产者或使用者的情况下，循环缓冲区不需要锁定。生产者是唯一允许修改写索引及其指向的数组位置的线程。只要写者在更新写索引之前将新值存储到缓冲区中，读者将始终看到一致的视图。反过来，读取器是唯一可以访问读取索引及其指向的值的线程。小心确保两个指针不会彼此溢出，生产者和使用者可以在没有竞争条件的情况下同时访问缓冲区。

前一段时间，我已经找到了解决这个问题的好方法。我相信它是迄今为止发现的最小的。

该存储库提供了一个示例，说明如何使用它创建N个线程（读者和作家），然后共享一个席位。

我在测试示例中做了一些基准测试，并得到以下结果（以百万次操作/秒为单位）：

按缓冲区大小

按线程数

请注意，线程数不会改变吞吐量。

我认为这是解决这个问题的最终方法。它的工作原理是令人难以置信的快速和简单。即使有数百个线程和一个位置的队列。它可用作线程之间的管道，在队列内分配空间。

该存储库具有一些用C＃和pascal编写的早期版本。我正在努力使某些东西更完整地抛光，以显示其真正的力量。

我希望你们中的一些人可以验证工作或提供一些想法。或者至少可以打破它？

如果以缓冲区永远不会变满为前提，请考虑使用以下无锁算法：

capacity must be a power of 2
buffer = new T[capacity] ~ on different cache line
mask = capacity - 1
write_index ~ on different cache line
read_index ~ on different cache line

enqueue:
    write_i = write_index.fetch_add(1) & mask
    buffer[write_i] = element ~ release store

dequeue:
    read_i = read_index.fetch_add(1) & mask
    element
    while ((element = buffer[read_i] ~ acquire load) == NULL) {
        spin loop
    }
    buffer[read_i] = NULL ~ relaxed store
    return element