Disruptor--Quick Start

董不懂

已于 2022-07-01 14:38:53 修改

阅读量76

点赞数

文章标签： java

于 2022-06-10 21:50:45 首次发布

本文链接：https://blog.csdn.net/aserghuil/article/details/125228710

版权

这篇博客介绍了如何使用Disruptor框架创建一个高性能的队列，包括设置EventTranslatorOneArg进行事件转换，通过RingBuffer进行数据发布，并且实现了一个DisruptorEventHandler来监听和处理事件。Disruptor的使用显著提高了并发处理能力和效率。

摘要由CSDN通过智能技术生成

注册队列并生产

public class DisruptorQueue<T> extends AbstractQueue<T> {
 
    private final EventTranslatorOneArg translator;
    private final RingBuffer ringBuffer;
    private final Disruptor disruptor;
    private final int bufferSize;
    private static final int RINGBUFFER_DEFAULT_SIZE = 4 * 1024;
 
    public DisruptorQueue(EventFactory eventFactory , EventTranslatorOneArg translator , DisruptorEventHandler eventHandler) {
        super(eventHandler);
        bufferSize = getBufferSize();
        Disruptor disruptor = new Disruptor<>(eventFactory, bufferSize,
                new ThreadUtils(getClass().getSimpleName()), ProducerType.MULTI, new BlockingWaitStrategy());
        disruptor.handleEventsWith(eventHandler);
        this.translator = translator;
        this.ringBuffer = disruptor.getRingBuffer();
        this.disruptor = disruptor;
    }
 
    @Override
    public void publish(T item) {
        if (!ringBuffer.tryPublishEvent(translator, item)) {
            ringBuffer.publishEvent(translator, item);
        }
    }
 
    @Override
    public void start() {
        super.start();
        disruptor.start();
    }
 
    @Override
    public void close() {
        super.close();
        disruptor.shutdown();
    }
 
    @Override
    public int size() {
        return bufferSize - (int) ringBuffer.remainingCapacity();
    }
 
    private static int getBufferSize() {
        return RINGBUFFER_DEFAULT_SIZE;
    }
}

监听事件并消费

public abstract class DisruptorEventHandler<T> implements EventHandler<EventHolder<T>> {
 
    protected final boolean allowDiscard = true;
    private final AtomicBoolean running = new AtomicBoolean(false);
    private final AtomicLong failCount = new AtomicLong(0);
 
    public void onEvent(EventHolder eventHolder, long sequence, boolean endOfBatch) {
        T event = eventHolder.getEvent();
        if (event != null && isRunning()) {
            handleEvent(event, endOfBatch);
        }
        eventHolder.setEvent(null);
    }
 
    public abstract void handleEvent(T eventItem, boolean endOfBatch);
 
    public boolean isRunning() {
        return running.get();
    }
 
    public void start() {
        running.getAndSet(true);
    }
 
    public void close() {
        running.getAndSet(false);
    }
 
    protected void incrementFailCount(long delta) {
        failCount.addAndGet(delta);
    }
 
    public long getFailCount() {
        return failCount.get();
    }
}