Java Code Examples for com.lmax.disruptor.RingBuffer#get()

@Override
protected void channelRead0(ChannelHandlerContext ctx, String msg) throws Exception {
    RingBuffer<ConcurrentEvent> ringBuffer = THREAD_LOCAL.get().getRingBuffer();
    long next = ringBuffer.next();
    try {
        ConcurrentEvent commandEvent = ringBuffer.get(next);
        commandEvent.setValues(new Executor() {
            @Override
            public void onExecute() {
                ctx.channel().writeAndFlush(msg);
            }

            @Override
            public void release() {
            }
        });
    } finally {
        ringBuffer.publish(next);
    }
}
 

@Override
protected void channelRead0(ChannelHandlerContext ctx, O msg) throws Exception {
    UUID uuid = CHANNEL_UUID.get(ctx.channel());
    if (null != uuid) {
        Session session = SESSIONS.get(uuid);
        if (null != session) {
            RingBuffer<ConcurrentEvent> ringBuffer = THREAD_LOCAL.get().getRingBuffer();
            long next = ringBuffer.next();
            try {
                ConcurrentEvent commandEvent = ringBuffer.get(next);
                commandEvent.setValues(newExecutor(session, msg));
            } finally {
                ringBuffer.publish(next);
            }
        }
    }
}
 

@Override
public void emitAccount(AccountField account) {
	// 发送事件

	RingBuffer<FastEvent> ringBuffer = getRingBuffer();
	long sequence = ringBuffer.next(); // Grab the next sequence
	try {
		FastEvent fastEvent = ringBuffer.get(sequence); // Get the entry in the Disruptor for the sequence
		fastEvent.setObj(account);
		fastEvent.setEvent(account.getAccountId());
		fastEvent.setFastEventType(FastEventType.ACCOUNT);
	} finally {
		ringBuffer.publish(sequence);
	}

}
 

@Override
public void emitContract(ContractField contract) {

	// 发送事件

	RingBuffer<FastEvent> ringBuffer = getRingBuffer();
	long sequence = ringBuffer.next(); // Grab the next sequence
	try {
		FastEvent fastEvent = ringBuffer.get(sequence); // Get the entry in the Disruptor for the sequence
		fastEvent.setObj(contract);
		fastEvent.setEvent(contract.getContractId());
		fastEvent.setFastEventType(FastEventType.CONTRACT);
	} finally {
		ringBuffer.publish(sequence);
	}

}
 

@Override
public void emitTick(TickField tick) {

	RingBuffer<FastEvent> ringBuffer = getRingBuffer();
	long sequence = ringBuffer.next(); // Grab the next sequence
	try {
		FastEvent fastEvent = ringBuffer.get(sequence); // Get the entry in the Disruptor for the sequence
		fastEvent.setObj(tick);
		fastEvent.setEvent(tick.getUnifiedSymbol()+"@"+tick.getGatewayId());
		fastEvent.setFastEventType(FastEventType.TICK);

	} finally {
		ringBuffer.publish(sequence);
	}

}
 

@Override
public void emitTrade(TradeField trade) {

	// 发送特定合约成交事件
	RingBuffer<FastEvent> ringBuffer = getRingBuffer();
	long sequence = ringBuffer.next(); // Grab the next sequence
	try {
		FastEvent fastEvent = ringBuffer.get(sequence); // Get the entry in the Disruptor for the sequence
		fastEvent.setObj(trade);
		fastEvent.setEvent(trade.getOriginOrderId());
		fastEvent.setFastEventType(FastEventType.TRADE);

	} finally {
		ringBuffer.publish(sequence);
	}

}
 

@Override
public void run() {
    while (true) {
        Executor executor;
        while ((executor = msgQueue.poll()) != null) {
            RingBuffer<ConcurrentEvent> rb = disruptor.getRingBuffer();
            long next = rb.next();
            try {
                ConcurrentEvent event = rb.get(next);
                event.setValues(executor);
            } finally {
                rb.publish(next);
                waitSize.decrementAndGet();
            }
        }
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
 

@Override
public boolean dispatch(Runnable message) {
    RingBuffer<MessageEvent<Runnable>> ringBuffer = disruptor.getRingBuffer();
    try {
        long sequence = ringBuffer.tryNext();
        try {
            MessageEvent<Runnable> event = ringBuffer.get(sequence);
            event.setMessage(message);
        } finally {
            ringBuffer.publish(sequence);
        }
        return true;
    } catch (InsufficientCapacityException e) {
        // 这个异常是Disruptor当做全局goto使用的, 是单例的并且没有堆栈信息, 不必担心抛出异常的性能问题
        return false;
    }
}
 

@Override
public boolean dispatch(final Runnable message) {
    final RingBuffer<MessageEvent<Runnable>> ringBuffer = disruptor.getRingBuffer();
    try {
        final long sequence = ringBuffer.tryNext();
        try {
            final MessageEvent<Runnable> event = ringBuffer.get(sequence);
            event.setMessage(message);
        } finally {
            ringBuffer.publish(sequence);
        }
        return true;
    } catch (final InsufficientCapacityException e) {
        // This exception is used by the Disruptor as a global goto. It is a singleton
        // and has no stack trace.  Don't worry about performance.
        return false;
    }
}
 

private static DisruptorEventQueue create() {
  // Create new Disruptor for processing. Note that Disruptor creates a single thread per
  // consumer (see https://github.com/LMAX-Exchange/disruptor/issues/121 for details);
  // this ensures that the event handler can take unsynchronized actions whenever possible.
  Disruptor<DisruptorEvent> disruptor =
      new Disruptor<>(
          DisruptorEventFactory.INSTANCE,
          DISRUPTOR_BUFFER_SIZE,
          new DaemonThreadFactory("OpenCensus.Disruptor"),
          ProducerType.MULTI,
          new SleepingWaitStrategy(0, 1000 * 1000));
  disruptor.handleEventsWith(new DisruptorEventHandler[] {DisruptorEventHandler.INSTANCE});
  disruptor.start();
  final RingBuffer<DisruptorEvent> ringBuffer = disruptor.getRingBuffer();

  DisruptorEnqueuer enqueuer =
      new DisruptorEnqueuer() {
        @Override
        public void enqueue(Entry entry) {
          long sequence = ringBuffer.next();
          try {
            DisruptorEvent event = ringBuffer.get(sequence);
            event.setEntry(entry);
          } finally {
            ringBuffer.publish(sequence);
          }
        }
      };
  return new DisruptorEventQueue(disruptor, enqueuer);
}
 

@Override
protected void channelRead0(ChannelHandlerContext ctx, O msg) throws Exception {
    Session session = SESSIONS.get(ctx.channel().id());
    if (null == session) {
        return;
    }
    RingBuffer<ConcurrentEvent> ringBuffer = THREAD_LOCAL.get().getRingBuffer();
    long next = ringBuffer.next();
    try {
        ConcurrentEvent commandEvent = ringBuffer.get(next);
        commandEvent.setValues(newExecutor(session, msg));
    } finally {
        ringBuffer.publish(next);
    }
}
 

public static <E> void onComplete(RingBuffer<MutableSignal<E>> ringBuffer) {
  final long seqId = ringBuffer.next();
  final MutableSignal<E> signal = ringBuffer.get(seqId);

  signal.type = MutableSignal.Type.COMPLETE;
  signal.value = null;
  signal.error = null;

  ringBuffer.publish(seqId);
}
 

public static <E> void onError(Throwable error, RingBuffer<MutableSignal<E>> ringBuffer) {
  if (error == null) {
    throw SpecificationExceptions.spec_2_13_exception();
  }

  final long seqId = ringBuffer.next();
  final MutableSignal<E> signal = ringBuffer.get(seqId);

  signal.type = MutableSignal.Type.ERROR;
  signal.value = null;
  signal.error = error;

  ringBuffer.publish(seqId);
}
 

public static <E> void onNext(E value, RingBuffer<MutableSignal<E>> ringBuffer) {
  if (value == null) {
    throw SpecificationExceptions.spec_2_13_exception();
  }

  final long seqId = ringBuffer.next();
  final MutableSignal<E> signal = ringBuffer.get(seqId);
  signal.type = MutableSignal.Type.NEXT;
  signal.value = value;

  ringBuffer.publish(seqId);
}
 

private void produce(final RingBuffer<ValueEvent> ringBuffer, final int count, final boolean addDelay) {
    for (int i = 0; i < count; i++) {
        final long seq = ringBuffer.next();
        final ValueEvent valueEvent = ringBuffer.get(seq);
        valueEvent.setValue(i);
        ringBuffer.publish(seq);
        if (addDelay) {
            addDelay();
        }
    }
}
 

private void produce(final RingBuffer<ValueEvent> ringBuffer, final int count) {
    for (int i = 0; i < count; i++) {
        final long seq = ringBuffer.next();
        final ValueEvent valueEvent = ringBuffer.get(seq);
        valueEvent.setValue(i);
        ringBuffer.publish(seq);
    }
}
 

@Override
public void emitPosition(PositionField position) {

	RingBuffer<FastEvent> ringBuffer = getRingBuffer();
	long sequence = ringBuffer.next(); // Grab the next sequence
	try {
		FastEvent fastEvent = ringBuffer.get(sequence); // Get the entry in the Disruptor for the sequence
		fastEvent.setObj(position);
		fastEvent.setEvent(position.getPositionId());
		fastEvent.setFastEventType(FastEventType.POSITION);

	} finally {
		ringBuffer.publish(sequence);
	}
}
 

@Override
public void emitEvent(FastEventType fastEventType, String event, Object obj) {
	RingBuffer<FastEvent> ringBuffer = getRingBuffer();
	long sequence = ringBuffer.next(); // Grab the next sequence
	try {
		FastEvent fastEvent = ringBuffer.get(sequence); // Get the entry in the Disruptor for the sequence
		fastEvent.setFastEventType(fastEventType);
		fastEvent.setEvent(event);
		fastEvent.setObj(obj);

	} finally {
		ringBuffer.publish(sequence);
	}
}
 

@Override
public void publish(BaseEvent baseEvent) {
    RingBuffer<BaseEvent> ringBuffer = disruptor.getRingBuffer();
    long sequence = ringBuffer.next();
    try {
        // Get the entry in the Disruptor
        BaseEvent event = ringBuffer.get(sequence);
        // for the sequence   // Fill with data
        event.setBlockPacket(baseEvent.getBlockPacket());
        event.setChannelContext(baseEvent.getChannelContext());
    } finally {
        ringBuffer.publish(sequence);
    }
}
 

public static <T> boolean waitRequestOrTerminalEvent(
  Sequence pendingRequest,
  RingBuffer<MutableSignal<T>> ringBuffer,
  SequenceBarrier barrier,
  Subscriber<? super T> subscriber,
  AtomicBoolean isRunning
) {
  final long waitedSequence = ringBuffer.getCursor() + 1L;
  try {
    MutableSignal<T> event = null;
    while (pendingRequest.get() < 0l) {
      //pause until first request
      if (event == null) {
        barrier.waitFor(waitedSequence);
        event = ringBuffer.get(waitedSequence);

        if (event.type == MutableSignal.Type.COMPLETE) {
          try {
            subscriber.onComplete();
            return false;
          } catch (Throwable t) {
            Exceptions.throwIfFatal(t);
            subscriber.onError(t);
            return false;
          }
        } else if (event.type == MutableSignal.Type.ERROR) {
          subscriber.onError(event.error);
          return false;
        }
      } else {
        barrier.checkAlert();
      }
      LockSupport.parkNanos(1l);
    }
  } catch (TimeoutException te) {
    //ignore
  } catch (AlertException ae) {
    if (!isRunning.get()) {
      return false;
    }
  } catch (InterruptedException ie) {
    Thread.currentThread().interrupt();
  }

  return true;
}