Java RingBuffer.newBarrier方法代码示例

import com.lmax.disruptor.RingBuffer; //导入方法依赖的package包/类
@Override
    public void startup() {
        EventBus eventBus = disruptorDispatchThread.getEventBus();
        executorService = new NonOrderedQueuePoolExecutor(poolName, excutorSize);
        cycleEventHandler = new CycleEventHandler[excutorSize];
        for(int i = 0; i < excutorSize; i++){
            cycleEventHandler[i] = new CycleEventHandler(eventBus);
        }

        RingBuffer ringBuffer = disruptorDispatchThread.getRingBuffer();
        workerPool = new WorkerPool(ringBuffer, ringBuffer.newBarrier(), new FatalExceptionHandler(), cycleEventHandler);
        ringBuffer.addGatingSequences(workerPool.getWorkerSequences());

        workerPool.start(executorService);

//        BatchEventProcessor<CycleEvent>[] batchEventProcessors = new BatchEventProcessor[excutorSize];
//        for(int i = 0; i < excutorSize; i++){
//            batchEventProcessors[i] = new BatchEventProcessor<>(ringBuffer, sequenceBarrier, cycleEventHandler[i]);
//            ringBuffer.addGatingSequences(batchEventProcessors[i].getSequence());
////            executorService.submit(batchEventProcessors[i]);
//        }
    }
 

import com.lmax.disruptor.RingBuffer; //导入方法依赖的package包/类
@Test
public void shouldSupportCustomProcessorsAsDependencies()
    throws Exception
{
    RingBuffer<TestEvent> ringBuffer = disruptor.getRingBuffer();

    final DelayedEventHandler delayedEventHandler = createDelayedEventHandler();

    CountDownLatch countDownLatch = new CountDownLatch(2);
    EventHandler<TestEvent> handlerWithBarrier = new EventHandlerStub<TestEvent>(countDownLatch);

    final BatchEventProcessor<TestEvent> processor =
        new BatchEventProcessor<TestEvent>(ringBuffer, ringBuffer.newBarrier(), delayedEventHandler);
    disruptor.handleEventsWith(processor);
    disruptor.after(processor).handleEventsWith(handlerWithBarrier);

    ensureTwoEventsProcessedAccordingToDependencies(countDownLatch, delayedEventHandler);
}
 

import com.lmax.disruptor.RingBuffer; //导入方法依赖的package包/类
RingBufferConsumer(@Nonnull final RingBuffer<T> buffer, @Nonnull final Object[] attachments) {
	if (buffer == null) {
		throw new NullPointerException("buffer == null");
	}
	if (attachments == null) {
		throw new NullPointerException("attachments == null");
	}
	if (buffer.getBufferSize() != attachments.length) {
		throw new IllegalArgumentException("buffer.getBufferSize() != attachments.length");
	}
	this.buffer = buffer;
	this.attachments = attachments;
	this.barrier = buffer.newBarrier();
	this.sequence = new Sequence();
	buffer.addGatingSequences(sequence);
	this.cursor = sequence.get();
	this.available = sequence.get();
}
 

import com.lmax.disruptor.RingBuffer; //导入方法依赖的package包/类
public static void main(String[] args) {
	
	final List<ValueEventHandler1PMC> handlers = new ArrayList<>(NUMBER_CONSUMERS);
			
	RingBuffer<ValueEvent> ringBuffer = RingBuffer.createSingleProducer(
			ValueEvent.EVENT_FACTORY, RING_SIZE, new SleepingWaitStrategy());

	start = System.nanoTime();

	//Create consumers
	for(int i = 0;  i < NUMBER_CONSUMERS; i++) {
		ValueEventHandler1PMC handler = new ValueEventHandler1PMC(start, handlers);
		handlers.add(handler);
		SequenceBarrier barrier = ringBuffer.newBarrier();
		BatchEventProcessor<ValueEvent> eventProcessor = new BatchEventProcessor<ValueEvent>(
				ringBuffer,	barrier, handler);
		ringBuffer.addGatingSequences(eventProcessor.getSequence());

		// Each EventProcessor can run on a separate thread
		EXECUTOR.submit(eventProcessor);
	}
	
	for(int i = 0;  i  < SAMPLES_SIZE; i++) {
		// Publishers claim events in sequence
		long sequence = ringBuffer.next();
		ValueEvent event = ringBuffer.get(sequence);

		event.setValue(i); // this could be more complex with multiple fields
		
		// make the event available to EventProcessors
		ringBuffer.publish(sequence);   
	}

}
 

import com.lmax.disruptor.RingBuffer; //导入方法依赖的package包/类
public static void main(String[] args) {
				
		RingBuffer<ValueEvent> ringBuffer = RingBuffer.createSingleProducer(
				ValueEvent.EVENT_FACTORY, RING_SIZE, new SleepingWaitStrategy());

		start = System.nanoTime();

		//Create first consumer
		ValueEventHandler1PMCSequenceFirst handler = new ValueEventHandler1PMCSequenceFirst(start);
		SequenceBarrier barrier;
		barrier = ringBuffer.newBarrier();
		BatchEventProcessor<ValueEvent> firstEventProcessor = new BatchEventProcessor<ValueEvent>(
				ringBuffer,	barrier, handler);
//		ringBuffer.addGatingSequences(firstEventProcessor.getSequence());
		
		// Each EventProcessor can run on a separate thread
		EXECUTOR.submit(firstEventProcessor);

		//Create second consumer
		ValueEventHandler1PMCSequenceSecond handler2 = new ValueEventHandler1PMCSequenceSecond(start);
		SequenceBarrier barrier2 = ringBuffer.newBarrier(firstEventProcessor.getSequence());
		BatchEventProcessor<ValueEvent> secondEventProcessor = new BatchEventProcessor<ValueEvent>(
				ringBuffer,	barrier2, handler2);
		ringBuffer.addGatingSequences(secondEventProcessor.getSequence());
		
		// Each EventProcessor can run on a separate thread
		EXECUTOR.submit(secondEventProcessor);

		
		for(int i = 0;  i  < SAMPLES_SIZE; i++) {
			// Publishers claim events in sequence
			long sequence = ringBuffer.next();
			ValueEvent event = ringBuffer.get(sequence);

			event.setValue(i); // this could be more complex with multiple fields
			
			// make the event available to EventProcessors
			ringBuffer.publish(sequence);   
		}

	}