Disruptor源码分析

        long sequence = ringBuffer.next();  // 第一阶段，获取RingBuffer上下一个可用的slot的序列号，这里可能会有争用
        try {
            Event event = ringBuffer.get(sequence); // 根据序列号直接去RingBuffer上获取对应的slot上存储的事件
            event.setData(data);  // 写入数据
        } finally {
            ringBuffer.publish(sequence); // 第二阶段，将这个事件正式发布到RingBuffer中
        }

SingleProducerSequencer.next()
    @Override
    public long next()
    {
        return next(1);
    }

    @Override
    public long next(int n)
    {
        if (n < 1)//参数检验
        {
            throw new IllegalArgumentException("n must be > 0");
        }

        long nextValue = this.nextValue;//上一次返回的seq

        long nextSequence = nextValue + n;//这次应该返回的序列值，这个序列值还未被产生，对应的slot里的元素的seq需要减去RingBuffer的大小
        long wrapPoint = nextSequence - bufferSize;//这个序列值对应的slot上正在存储的元素的seq，这个slot可能已经被消费了，也可能没有
        long cachedGatingSequence = this.cachedValue;//获取消费者未消费的元素的seq最小值，这个值不是实时的

        //wrapPoint > cachedGatingSequence，检查将要被放入元素的slot是否已经没有消费者占用了
        //cachedGatingSequence > nextValue，用于来应对seq发生溢出的情况
        if (wrapPoint > cachedGatingSequence || cachedGatingSequence > nextValue)
        {
            cursor.setVolatile(nextValue);  // StoreLoad fence，更新RingBuffer的游标，用到了Unsafe方法

            long minSequence;
            //Util.getMinimumSequence可以获得所有消费者未消费事件的seq最小值，在比这个值更小的slot里发布元素是安全的
            //如果这个判断成立，说明生产者正在试图将元素放到消费者未消费完毕的slot里，这个操作是不安全的，生产者需要在这里被阻塞
            while (wrapPoint > (minSequence = Util.getMinimumSequence(gatingSequences, nextValue)))
            {
                waitStrategy.signalAllWhenBlocking();//激活所有的消费者（避免有的消费者睡死过去了）
                LockSupport.parkNanos(1L); // TODO: Use waitStrategy to spin? 自旋等待
            }

            this.cachedValue = minSequence;//更新cachedValue
        }

        this.nextValue = nextSequence;

        return nextSequence;
    }