EventHandlerGroup<T> createWorkerPool( final Sequence[] barrierSequences, final WorkHandler<? super T>[] workHandlers) { final SequenceBarrier sequenceBarrier = ringBuffer.newBarrier(barrierSequences); final WorkerPool<T> workerPool = new WorkerPool<>(ringBuffer, sequenceBarrier, exceptionHandler, workHandlers); consumerRepository.add(workerPool, sequenceBarrier); final Sequence[] workerSequences = workerPool.getWorkerSequences(); updateGatingSequencesForNextInChain(barrierSequences, workerSequences); return new EventHandlerGroup<>(this, consumerRepository, workerSequences); }
@Override public void start(Executor executor) { workerPool.start(executor); }
@Override public void halt() { workerPool.halt(); }
workHandlers[i] = new DmlParserStage(); workerPool = new WorkerPool<MessageEvent>(disruptorMsgBuffer, dmlParserSequenceBarrier, exceptionHandler, workHandlers); Sequence[] sequence = workerPool.getWorkerSequences(); disruptorMsgBuffer.addGatingSequences(sequence); workerPool.start(parserExecutor);
@Override public Sequence[] getSequences() { return workerPool.getWorkerSequences(); }
@SuppressWarnings("unchecked") @Test public void shouldProcessOnlyOnceItHasBeenPublished() throws Exception { Executor executor = Executors.newCachedThreadPool(DaemonThreadFactory.INSTANCE); WorkerPool<AtomicLong> pool = new WorkerPool<AtomicLong>( new AtomicLongEventFactory(), new FatalExceptionHandler(), new AtomicLongWorkHandler(), new AtomicLongWorkHandler()); RingBuffer<AtomicLong> ringBuffer = pool.start(executor); ringBuffer.next(); ringBuffer.next(); Thread.sleep(1000); assertThat(ringBuffer.get(0).get(), is(0L)); assertThat(ringBuffer.get(1).get(), is(0L)); }
WorkerPool pool = new WorkerPool(); pool.submit("2", task1); pool.submit("2", task2); pool.submit("3", task3); pool.submit("2", task4);
var Workers = new WorkerPool(); var worker1 = Workers.addWorker(); worker1.enqueue(function(){
/** * */ public void shutdown() { if (m_worker.isRunning()) { m_worker.drainAndHalt(); m_executor.shutdown(); LOGGER.warn( "RequestQueueProcessor : " + m_name + " Shutting down"); } }
@Override public boolean isRunning() { return workerPool.isRunning(); } }
@Override public void shutdown() { workerPool.drainAndHalt(); }
@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]); // } }
public void add(final WorkerPool<T> workerPool, final SequenceBarrier sequenceBarrier) { final WorkerPoolInfo<T> workerPoolInfo = new WorkerPoolInfo<>(workerPool, sequenceBarrier); consumerInfos.add(workerPoolInfo); for (Sequence sequence : workerPool.getWorkerSequences()) { eventProcessorInfoBySequence.put(sequence, workerPoolInfo); } }
@SuppressWarnings("unchecked") @Test public void shouldProcessEachMessageByOnlyOneWorker() throws Exception { Executor executor = Executors.newCachedThreadPool(DaemonThreadFactory.INSTANCE); WorkerPool<AtomicLong> pool = new WorkerPool<AtomicLong>( new AtomicLongEventFactory(), new FatalExceptionHandler(), new AtomicLongWorkHandler(), new AtomicLongWorkHandler()); RingBuffer<AtomicLong> ringBuffer = pool.start(executor); ringBuffer.next(); ringBuffer.next(); ringBuffer.publish(0); ringBuffer.publish(1); Thread.sleep(500); assertThat(ringBuffer.get(0).get(), is(1L)); assertThat(ringBuffer.get(1).get(), is(1L)); }
public RpcServer build() { final int workerThreads = 3; Producer<String, Response> responseProducer = new KafkaProducer<>(producerProps, new StringSerializer(), producerValueSerializer); final ServerEventHandler[] workHandlers = new ServerEventHandler[workerThreads]; IntStream.range(0, workerThreads).forEach( nbr -> workHandlers[nbr] = new ServerEventHandler(requestHandler, responseProducer) ); final WorkerPool<ServerEvent> workerPool = new WorkerPool<>(ServerEvent::new, new FatalExceptionHandler(), workHandlers); RequestConsumer requestConsumer = new RequestConsumer(topic, consumerProps, consumerThreads, consumerValueDeserializer); return new KafkaRpcServer(workerPool, requestConsumer, new ServerEventHandler(requestHandler, responseProducer), workerThreads); }
@Override public boolean isRunning() { return workerPool.isRunning(); } }
@Override public void destroy() throws Exception { if (m_workerPool != null) { m_workerPool.drainAndHalt(); } }
private void setUpWorkerPool() { // Executor that will be used to construct new threads for consumers final ThreadFactory namedThreadFactory = new ThreadFactoryBuilder() .setNameFormat("NewtsWriter-Consumer-%d").build(); final Executor executor = Executors.newCachedThreadPool(namedThreadFactory); @SuppressWarnings("unchecked") final WorkHandler<SampleBatchEvent> handlers[] = new WorkHandler[m_numWriterThreads]; for (int i = 0; i < m_numWriterThreads; i++) { handlers[i] = this; } m_ringBuffer = RingBuffer.createMultiProducer(SampleBatchEvent::new, m_ringBufferSize); m_workerPool = new WorkerPool<SampleBatchEvent>( m_ringBuffer, m_ringBuffer.newBarrier(), new FatalExceptionHandler(), handlers); m_ringBuffer.addGatingSequences(m_workerPool.getWorkerSequences()); m_workerPool.start(executor); }
EventHandlerGroup<T> createWorkerPool( final Sequence[] barrierSequences, final WorkHandler<? super T>[] workHandlers) { final SequenceBarrier sequenceBarrier = ringBuffer.newBarrier(barrierSequences); final WorkerPool<T> workerPool = new WorkerPool<>(ringBuffer, sequenceBarrier, exceptionHandler, workHandlers); consumerRepository.add(workerPool, sequenceBarrier); final Sequence[] workerSequences = workerPool.getWorkerSequences(); updateGatingSequencesForNextInChain(barrierSequences, workerSequences); return new EventHandlerGroup<>(this, consumerRepository, workerSequences); }
/** * Wait for the {@link RingBuffer} to drain of published events then halt the workers. */ public void drainAndHalt() { Sequence[] workerSequences = getWorkerSequences(); while (ringBuffer.getCursor() > Util.getMinimumSequence(workerSequences)) { Thread.yield(); } for (WorkProcessor<?> processor : workProcessors) { processor.halt(); } started.set(false); }