Java Disruptor.handleEventsWithWorkerPool方法代码示例

import com.lmax.disruptor.dsl.Disruptor; //导入方法依赖的package包/类
@Provides
@Singleton
@Named("firstPassDisruptor")
public Disruptor<TwoPhaseEvent<Void>> firstPassDisruptor(
        Provider<WorkHandler<TwoPhaseEvent<Void>>> statisticsHandlerProvider) {
    Disruptor<TwoPhaseEvent<Void>> disruptor = new Disruptor<>(
            TwoPhaseEvent.factory(() -> null),
            options.ringSize(), threadsProvider,
            ProducerType.SINGLE, new SleepingWaitStrategy());
    WorkHandler<TwoPhaseEvent<Void>>[] parsers = new WorkHandler[options.threads()];
    for (int i = 0; i < options.threads(); i++) {
        parsers[i] = statisticsHandlerProvider.get();
    }
    disruptor.handleExceptionsWith(new FatalExceptionHandler());
    disruptor.handleEventsWithWorkerPool(parsers);
    return disruptor;
}
 

import com.lmax.disruptor.dsl.Disruptor; //导入方法依赖的package包/类
/**
 * add some handler to worker pool of the disruptor
 *
 * @param name
 * @param handler
 */
public void handleEventsWithWorkerPool(String name, WorkHandler<DisruptorEvent<ProcessData>>... handler) {
    Disruptor disruptor = DISRUPTOR_MAP.get(name);
    AssertUtil.canNotEmpty(disruptor, "the disruptor is not exist!name:" + name);
    disruptor.handleEventsWithWorkerPool(handler);


}
 

import com.lmax.disruptor.dsl.Disruptor; //导入方法依赖的package包/类
/**
 * 初始化正常管道，任何情况下都会有
 *
 * @param pool 线程池
 */
private void initNormalChannel(ExecutorService pool) {
    Disruptor<ElectronsHolder> normalDis = new Disruptor<>(ElectronsHolder::new, conf.getCircuitLen(), pool, ProducerType.MULTI, new LiteBlockingWaitStrategy());
    WorkHandler[] workHandlers = new WorkHandler[conf.getCircuitNum()];
    Arrays.fill(workHandlers, (WorkHandler<ElectronsHolder>) electronsHolder -> electronsHolder.handle());
    normalDis.handleEventsWithWorkerPool(workHandlers);
    normalDis.handleExceptionsWith(new ElecExceptionHandler("Normal Disruptor"));

    //初始化channel
    Channel normalChannel = new NormalChannel(normalDis);
    //配置限流相关
    normalChannel.confLimitRate(conf.isLimitRate(), conf.getPermitsPerSecond(), conf.isWarmup(), conf.getWarmupPeriod(), conf.getWarmPeriodUnit());
    channelMap.put(NORMAL_CHANNEL_KEY, normalChannel);
}
 

import com.lmax.disruptor.dsl.Disruptor; //导入方法依赖的package包/类
public static void main(String[] args) throws Exception
    {
    	final Logger log=LoggerFactory.getLogger("");
        // Executor that will be used to construct new threads for consumers
        Executor executor = new ThreadPoolExecutor(1,1,0L, TimeUnit.MILLISECONDS,new LinkedBlockingQueue<Runnable>(),new NamedThreadFactory("disruptor"));

        // The factory for the event
        LongEventFactory factory = new LongEventFactory();

        // Specify the size of the ring buffer, must be power of 2.
        int bufferSize = 1024;

        // Construct the Disruptor
        final Disruptor<LongEvent<Runnable>> disruptor = new Disruptor<>(factory, bufferSize, executor);

        //注册消费者
        // Connect the handler
//        disruptor.handleEventsWith(new LongEventHandler("消费者A"),new LongEventHandler("消费者B"));
        disruptor.handleEventsWithWorkerPool(new LongEventWorkHandler("消费者C"),new LongEventWorkHandler("消费者D"));
        // Start the Disruptor, starts all threads running
        disruptor.start();
        final AtomicLong seq=new AtomicLong();
        //生产者1
        new Thread(new Runnable() {
			@Override
			public void run() {
				// Get the ring buffer from the Disruptor to be used for publishing.
				RingBuffer<LongEvent<Runnable>> ringBuffer = disruptor.getRingBuffer();
				LongEventProducer producer = new LongEventProducer(ringBuffer);
		        for (long l = 0; true; l++)
		        {
		            producer.publish(new Task("task:"+seq.incrementAndGet()));
		            try {
						Thread.sleep(RandomUtils.nextInt(1000));
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
		        }
			}
		}).start();
    }