Synchronization 干扰器，同步机制

当有N个生产者和1个消费者时，干扰者队列是否提供了优异的性能？我编写了一个程序，多个生产者和单个消费者使用中断器队列。我发现结果与阻塞阵列边界队列不相上下。后者表现更好。我做错什么了吗

public void asynchronous_execution( )
{
 // Set up the executor and disruptor
     ExecutorService exec = Executors.newCachedThreadPool();
     Disruptor<valueEvent> disruptor =
     new Disruptor<valueEvent>( valueEvent.EVENT_FACTORY,
                        globalVariables.RING_SIZE,       
                        exec );

 // Handler of Events
 final EventHandler<valueEvent> handler = new EventHandler<valueEvent>()
 {
     public void onEvent(final valueEvent event, final long sequence, 
                 final boolean endOfBatch) throws Exception
     {  .... }       

 };

 // Building Dependency Graph
 disruptor.handleEventsWith(handler);

 // Starting the disruptor
 final RingBuffer<valueEvent> ringBuffer = disruptor.start();


 // Producer Thread
 final long[] runtime = new long [globalVariables.NUMBER_OF_THREADS];

 final class ProducerThread extends Thread {
  ...

    public void run()
    {
      ..
          long sequence = ringBuffer.next();
          valueEvent event = ringBuffer.get(sequence);

          event.setValue(globalVariables.WRITE_CODE); 

          // make the event available to EventProcessors
          ringBuffer.publish(sequence);  

        ...
       }

       ...
 };


 ProducerThread[] threads = new ProducerThread[globalVariables.NUMBER_OF_THREADS];
 for (int i = 0; i < globalVariables.NUMBER_OF_THREADS; i++) {
    threads[i] = new ProducerThread( i );
    threads[i].start();
 }

 ....

public void异步\u执行（）
{
//设置执行者和破坏者
ExecutorService exec=Executors.newCachedThreadPool（）；
干扰器干扰器=
新的干扰器（valueEvent.EVENT_工厂，
全局变量。环的大小，
执行董事）；
//事件处理程序
final EventHandler=new EventHandler（）
{
public void onEvent（最终值事件、最终长序列、，
最终布尔值endOfBatch）引发异常
{  .... }       
};
//构建依赖关系图
干扰物.手柄（手柄）；
//启动干扰器
final-RingBuffer-RingBuffer=disruptor.start（）；
//生产者线程
final long[]runtime=new long[globalVariables.NUMBER_线程数]；
最终类ProducerThread扩展线程{
...
公开募捐
{
..
长序列=ringBuffer.next（）；
valueEvent事件=ringBuffer.get（序列）；
事件.setValue（全局变量.WRITE_代码）；
//使事件可供EventProcessors使用
发布（序列）；
...
}
...
};
ProducerThread[]threads=新的ProducerThread[globalVariables.线程数]；
for（int i=0；i

---

}

我怀疑您的事件处理程序非常快，因此在您的示例中，最主要的时间是生产者写入环，这不是由单个线程完成的，而是跨所有线程共享的；和ABQ一样。常见的策略是将MP1C环分成许多1P1C，然后依次轮询每个1P1C。否则，您能否提供一个最小的完整工作片段来复制问题？很难知道问题是生产者、处理者还是其他人之间的交互。谢谢，这很有意义。我修改了代码，以便事件处理程序花更多的时间处理请求。但行为还是一样。我认为将队列划分为1P1C更有意义。谢谢你的宝贵意见。我需要多个级别的权限才能共享代码片段。对于1P1C队列，您可能希望查看Martin Thompson在这方面的一些最新工作，以及上的讨论！非常有趣。谢谢我在考虑缓存线中的错误共享。我想这也可以用在C语言中