Java 并发框架 Disruptor 源码分析：RingBuffer

Java 并发框架 Disruptor 源码分析：RingBuffer

Disruptor 介绍

按照官方文档的说法：Disruptor 是一个高性能的线程间通信库。它来自于 LMAX 对并发、性能和非阻塞算法的研究，如今交易系统基础架构的核心部分。

The LMAX Disruptor is a high performance inter-thread messaging library. It grew out of LMAX’s research into concurrency, performance and non-blocking algorithms and today forms a core part of their Exchange’s infrastructure.

Disruptor 高性能的原因有以下几点：
1. 无锁数据结构 RingBuffer
2. 伪共享 & 缓存行填充

这篇文章里，我们首先介绍一下环形缓冲区 RingBuffer，然后深入源码分析一下 Disruptor 是如何做到无锁操作 RingBuffer的。

RingBuffer 介绍

环形缓冲区（ring buffer），是一种用于表示一个固定尺寸、头尾相连的缓冲区的数据结构，适合缓存数据流。RingBuffer 通常采用数组实现，对 CPU 缓存友好，性能比链表好。

一个圆形缓冲区有四个关键参数：
1. 内存地址。
2. 缓冲区长度。
3. 存储在缓冲区中的有效数据的开始位置：读指针。
4. 存储在缓冲区中的有效数据的结尾位置：写指针。

下面深入源码研究一下 Disruptor 中 RingBuffer 的实现，看看它使如何做到无锁读写的。

RingBuffer 源码分析

在看源码之前，需要先了解一下 Disruptor 是如何使用的：Disruptor 入门。

初始化

我们先来看一下 RingBuffer 类的构造方法：

public final class RingBuffer<E> extends RingBufferFields<E> implements Cursored, EventSequencer<E>, EventSink<E> 
{
   
   
    RingBuffer(EventFactory<E> eventFactory, Sequencer sequencer)
    {
        super(eventFactory, sequencer);
    }
}

abstract class RingBufferFields<E> extends RingBufferPad
{
    private static final int BUFFER_PAD;
    private static final long REF_ARRAY_BASE;
    private static final int REF_ELEMENT_SHIFT;
    private static final Unsafe UNSAFE = Util.getUnsafe();

    static
    {
        // 获取用户给定数组寻址的换算因子，也就是数组中每个元素引用所占字节数目
        final int scale = UNSAFE.arrayIndexScale(Object[].class);
        if (4 == scale)
        {
            REF_ELEMENT_SHIFT = 2;
        }
        else if (8 == scale)
        {
            REF_ELEMENT_SHIFT = 3;
        }
        else
        {
            throw new IllegalStateException("Unknown pointer size");
        }
        BUFFER_PAD = 128 / scale;
        // Including the buffer pad in the array base offset
        REF_ARRAY_BASE = UNSAFE.arrayBaseOffset(Object[].class) + (BUFFER_PAD << REF_ELEMENT_SHIFT);
    }

    RingBufferFields(EventFactory<E> eventFactory, Sequencer sequencer)
    {
        this.sequencer = sequencer;
        this.bufferSize = sequencer.getBufferSize();

        if (bufferSize < 1)
        {
            throw new IllegalArgumentException("bufferSize must not be less than 1");
        }
        if (Integer.bitCount(bufferSize) != 1)
        {
            // bufferSize 必须是 2 的 N 次方
            throw new IllegalArgumentException("bufferSize must be a power of 2");
        }

        this.indexMask = bufferSize - 1;
        this.entries = new Object[sequencer.getBufferSize() + 2 * BUFFER_PAD];
        fill(eventFactory);
    }
    // 只对数组中间的 bufferSize 个元素进行初始化
    private void fill(EventFactory<E> eventFactory)
    {
        for (int i = 0; i < bufferSize; i++)
        {
            entries[BUFFER_PAD + i] = eventFactory.newInstance();
        }
    }    
}   

先简单说明一下构造方法中两个参数：
1. Sequencer：生产者用于访问缓存的控制器，它持有消费者序号的引用；新事件发布后通过 WaitStrategy 通知正在等待的SequenceBarrier。
2. EventFactory：RingBuffer 中存储的元素的初始化工厂类。

从构造方法中我们看到“bufferSize must be a power of 2”，这么要求的目的是方便使用位操作来获取读写元素在内存中的位置，其效率比取余 % 操作高得多。RingBuffer 这一点和 Linux 内核中的 kfifo 是一致的。

申请的数组 entries 实际大小为 bufferSize + 2 * BUFFER_PAD，BUFFER_PAD 个数组元素占用 128 字节，也就是说在数组前后各加了 128 字节的填充，这主要是为了防止伪共享。

写操作

官方文档中写数据的示例如下：

// 自定义的 RingBuffer 中的数据
public class LongEvent {
   
   
    private long value;

    public void set(long value) {
        this.value = value;
    }
}

public class LongEventProd