Disruptor 3种EventProcessor实现类

BatchEventProcessor 一个消费者处理对象 表示一个消费者.


    //获取下一个消费下标位置
   long nextSequence = sequence.get() + 1L;
   //一直检查获取可以消费的产品位置.
while (true)
            {
                try
                {
  //获取消费产品位置 只有当可消费产品位置大于(nextSequence); 才返回availableSequence  否则等待
                    final long availableSequence = sequenceBarrier.waitFor(nextSequence);


          //将nextSequence到availableSequence)之间的算一批,然后获取处理这批消费产品 交给消费者处理eventHandler
                    while (nextSequence <= availableSequence)
                    {
                        event = dataProvider.get(nextSequence);
                        eventHandler.onEvent(event, nextSequence, nextSequence == availableSequence);
                        nextSequence++;
                    }
 
                    //记录最后一次消费的位置
                    sequence.set(availableSequence);
                }
                catch (final TimeoutException e)
                {
                    notifyTimeout(sequence.get());
                }
                catch (final AlertException ex)
                {
                    if (!running.get())
                    {
                        break;
                    }
                }
                catch (final Throwable ex)
                {
                    exceptionHandler.handleEventException(ex, nextSequence, event);
                    sequence.set(nextSequence);
                    nextSequence++;
                }
            }




  WorkProcessor 是WorkerPool创建的WorkProcessor[]数组中的一个消费者.workSequence是WorkerPool中的一个传给每个WorkProcessor对象的公共者workSequence对象.
主要是让多个WorkProcessor通过nextSequence = workSequence.get() + 1L;获取nextSequence值,然后通过cas竞争,看哪个WorkProcessor消费者抢到将workSequence更新为nextSequence 值,抢到的表示他获取了这个消费位置.
这样所有WorkProcessor都会通过竞争获取到一个nextSequence 消费位置.
相当于所有WorkProcessor最开始都会去竞争获取一个nextSequence,抢不到继续抢,
当WorkProcessor获取了该值后会与生产者生产位置achedAvailableSequence比较,
是否存在可以消费的产品,存在通过则event = ringBuffer.get(nextSequence);
 获取可以消费的产品,然后通过workHandler.onEvent(event);来实现消费部分逻辑.
假如生产者还没有生产可用产品(生产位置还没有大于消费位置)还未超过消费者消费位置,
则消费者 通过sequenceBarrier.waitFor(nextSequence);等待生产者超过消费位置,并获取cachedAvailableSequence 当前生产者当前位置,
然后再次if (cachedAvailableSequence >= nextSequence) 判断生产者位置是否大于消费者位置,大于则获取nextSequence所代表位置的产品,
并消费掉该产品,然后由重新回来抢nextSequence下一个消费位置.




        boolean processedSequence = true;
        long cachedAvailableSequence = Long.MIN_VALUE;
        //获取记录消费者位置 默认-1
        long nextSequence = sequence.get();
        T event = null;
        while (true)
        {
            try
            {
                // if previous sequence was processed - fetch the next sequence and set
                // that we have successfully processed the previous sequence
                // typically, this will be true
                // this prevents the sequence getting too far forward if an exception
                // is thrown from the WorkHandler
                //多个WorkProcessor
                if (processedSequence)
                {
                    processedSequence = false;
                    do
                    {
                        
                        nextSequence = workSequence.get() + 1L;
                        sequence.set(nextSequence - 1L);
                    }
                    while (!workSequence.compareAndSet(nextSequence - 1L, nextSequence));
                }


                if (cachedAvailableSequence >= nextSequence)
                {
                    event = ringBuffer.get(nextSequence);
                    workHandler.onEvent(event);
                    processedSequence = true;
                }
                else
                {
                    cachedAvailableSequence = sequenceBarrier.waitFor(nextSequence);
                }
            }
            catch (final AlertException ex)
            {
                if (!running.get())
                {
                    break;
                }
            }
            catch (final Throwable ex)
            {
                // handle, mark as processed, unless the exception handler threw an exception
                exceptionHandler.handleEventException(ex, nextSequence, event);
                processedSequence = true;
            }
        }
   




NoOpEventProcessor


  @Override
    public void run()
    {
        if (!running.compareAndSet(false, true))
        {
            throw new IllegalStateException("Thread is already running");
        }
    }




并没有做什么事情