public void run() { try { sequenceBarrier.waitFor(expectedNumberMessages - 1); } catch (AlertException e) { alerted[0] = true; } catch (Exception e) { // don't care } } });
private long getAvailableConsumeCursor() throws AlertException, InterruptedException, TimeoutException { final long nextSequence = _consumer.get() + 1; return _barrier.waitFor(nextSequence); }
@Override public List<StubEvent> call() throws Exception { cyclicBarrier.await(); sequenceBarrier.waitFor(toWaitForSequence); final List<StubEvent> messages = new ArrayList<StubEvent>(); for (long l = initialSequence; l <= toWaitForSequence; l++) { messages.add(ringBuffer.get(l)); } return messages; } }
@Override public void run() { if (!running.compareAndSet(false, true)) { throw new IllegalStateException("Already running"); } try { sequenceBarrier.waitFor(0L); } catch (Exception ex) { throw new RuntimeException(ex); } sequence.set(sequence.get() + 1L); } }
@Test public void shouldWaitOnPublication() throws Exception { SequenceBarrier barrier = sequencer.newBarrier(); long next = sequencer.next(10); long lo = next - (10 - 1); long mid = next - 5; for (long l = lo; l < mid; l++) { sequencer.publish(l); } assertThat(barrier.waitFor(-1), is(mid - 1)); for (long l = mid; l <= next; l++) { sequencer.publish(l); } assertThat(barrier.waitFor(-1), is(next)); }
final long nextSequence = _consumer.get() + 1; try { final long availableSequence = _barrier.waitFor(nextSequence); if (availableSequence >= nextSequence) { MutableObject mo = _buffer.get(nextSequence);
cachedAvailableSequence = sequenceBarrier.waitFor(nextSequence);
final long availableSequence = sequenceBarrier.waitFor(nextSequence); if (batchStartAware != null)
@Test public void shouldWaitForWorkCompleteWhereCompleteWorkThresholdIsBehind() throws Exception { long expectedNumberMessages = 10; fillRingBuffer(expectedNumberMessages); final DummyEventProcessor[] eventProcessors = new DummyEventProcessor[3]; for (int i = 0, size = eventProcessors.length; i < size; i++) { eventProcessors[i] = new DummyEventProcessor(); eventProcessors[i].setSequence(expectedNumberMessages - 2); } final SequenceBarrier sequenceBarrier = ringBuffer.newBarrier(Util.getSequencesFor(eventProcessors)); Runnable runnable = new Runnable() { public void run() { for (DummyEventProcessor stubWorker : eventProcessors) { stubWorker.setSequence(stubWorker.getSequence().get() + 1L); } } }; Thread thread = new Thread(runnable); thread.start(); thread.join(); long expectedWorkSequence = expectedNumberMessages - 1; long completedWorkSequence = sequenceBarrier.waitFor(expectedWorkSequence); assertTrue(completedWorkSequence >= expectedWorkSequence); }
long completedWorkSequence = sequenceBarrier.waitFor(expectedNumberMessages); assertTrue(completedWorkSequence >= expectedWorkSequence);
@Test public void shouldWaitForWorkCompleteWhereCompleteWorkThresholdIsAhead() throws Exception { final long expectedNumberMessages = 10; final long expectedWorkSequence = 9; fillRingBuffer(expectedNumberMessages); final Sequence sequence1 = new Sequence(expectedNumberMessages); final Sequence sequence2 = new Sequence(expectedWorkSequence); final Sequence sequence3 = new Sequence(expectedNumberMessages); final SequenceBarrier sequenceBarrier = ringBuffer.newBarrier(sequence1, sequence2, sequence3); long completedWorkSequence = sequenceBarrier.waitFor(expectedWorkSequence); assertTrue(completedWorkSequence >= expectedWorkSequence); }
@Test public void shouldWrap() throws Exception { int numMessages = ringBuffer.getBufferSize(); int offset = 1000; for (int i = 0; i < numMessages + offset; i++) { ringBuffer.publishEvent(StubEvent.TRANSLATOR, i, ""); } long expectedSequence = numMessages + offset - 1; long available = sequenceBarrier.waitFor(expectedSequence); assertEquals(expectedSequence, available); for (int i = offset; i < numMessages + offset; i++) { assertEquals(i, ringBuffer.get(i).getValue()); } }
@Test public void shouldClaimAndGetMultipleMessages() throws Exception { int numMessages = ringBuffer.getBufferSize(); for (int i = 0; i < numMessages; i++) { ringBuffer.publishEvent(StubEvent.TRANSLATOR, i, ""); } long expectedSequence = numMessages - 1; long available = sequenceBarrier.waitFor(expectedSequence); assertEquals(expectedSequence, available); for (int i = 0; i < numMessages; i++) { assertEquals(i, ringBuffer.get(i).getValue()); } }
@Test public void shouldClaimAndGet() throws Exception { assertEquals(SingleProducerSequencer.INITIAL_CURSOR_VALUE, ringBuffer.getCursor()); StubEvent expectedEvent = new StubEvent(2701); ringBuffer.publishEvent(StubEvent.TRANSLATOR, expectedEvent.getValue(), expectedEvent.getTestString()); long sequence = sequenceBarrier.waitFor(0); assertEquals(0, sequence); StubEvent event = ringBuffer.get(sequence); assertEquals(expectedEvent, event); assertEquals(0L, ringBuffer.getCursor()); }
public EventResultDisruptor waitFor() { SequenceBarrier barrier = ringBuffer.newBarrier(); try { long a = barrier.waitFor(waitAtSequence); if (ringBuffer != null) return ringBuffer.get(a); } catch (Exception e) { e.printStackTrace(); } finally { barrier.alert(); } return null; }
/** * not really block, the waiting time is longer than not block. */ public EventResultDisruptor waitForBlocking() { SequenceBarrier barrier = ringBuffer.newBarrier(); try { long a = barrier.waitFor(waitAtSequence); if (ringBuffer != null) return ringBuffer.get(a); } catch (Exception e) { e.printStackTrace(); } finally { barrier.alert(); } return null; }
cachedAvailableSequence = sequenceBarrier.waitFor(nextSequence);
final long availableSequence = sequenceBarrier.waitFor(nextSequence); if (batchStartAware != null)
public void consumeBatchWhenAvailable(EventHandler<Object> handler) { try { final long nextSequence = _consumer.get() + 1; long availableSequence = _barrier.waitFor(nextSequence); if (availableSequence >= nextSequence) { consumeBatchToCursor(availableSequence, handler); } } catch (TimeoutException te) { //Ignored } catch (AlertException e) { throw new RuntimeException(e); } catch (InterruptedException e) { throw new RuntimeException(e); } }
public void consumeBatchWhenAvailable(EventHandler<Object> handler) { try { final long nextSequence = _consumer.get() + 1; final long availableSequence = _barrier.waitFor(nextSequence, 10, TimeUnit.MILLISECONDS); if(availableSequence >= nextSequence) { consumeBatchToCursor(availableSequence, handler); } } catch (AlertException e) { throw new RuntimeException(e); } catch (InterruptedException e) { throw new RuntimeException(e); } }