public void run() { try { sequenceBarrier.waitFor(expectedNumberMessages - 1); } catch (AlertException e) { alerted[0] = true; } catch (Exception e) { // don't care } } });
private int applyWaitMethod(final SequenceBarrier barrier, int counter) throws AlertException { barrier.checkAlert(); if (0 == counter) { Thread.yield(); } else { --counter; } return counter; } }
@Override public void halt() { running.set(HALTED); sequenceBarrier.alert(); }
@Test public void shouldSetAndClearAlertStatus() { SequenceBarrier sequenceBarrier = ringBuffer.newBarrier(); assertFalse(sequenceBarrier.isAlerted()); sequenceBarrier.alert(); assertTrue(sequenceBarrier.isAlerted()); sequenceBarrier.clearAlert(); assertFalse(sequenceBarrier.isAlerted()); }
sequenceBarrier.clearAlert(); cachedAvailableSequence = sequenceBarrier.waitFor(nextSequence);
while (true) { try { final long availableSequence = processor.barrier.waitFor(nextSequence); while (nextSequence <= availableSequence) { event = processor.ringBuffer.get(nextSequence); pendingRequest.incrementAndGet(); processor.barrier.checkAlert(); LockSupport.parkNanos(1l); processor.barrier.alert(); break; } else { long cursor = processor.barrier.getCursor(); if (processor.ringBuffer.get(cursor).type == MutableSignal.Type.ERROR) { sequence.set(cursor); sequence.set(cursor - 1l); processor.barrier.clearAlert();
barrier.waitFor(waitedSequence); event = ringBuffer.get(waitedSequence); barrier.checkAlert();
sequenceBarrier.clearAlert();
@Test public void shouldSupportUsingWorkerPoolAsDependency() throws Exception { final TestWorkHandler workHandler1 = createTestWorkHandler(); final TestWorkHandler workHandler2 = createTestWorkHandler(); final DelayedEventHandler delayedEventHandler = createDelayedEventHandler(); disruptor.handleEventsWithWorkerPool(workHandler1, workHandler2).then(delayedEventHandler); publishEvent(); publishEvent(); assertThat(disruptor.getBarrierFor(delayedEventHandler).getCursor(), equalTo(-1L)); workHandler2.processEvent(); workHandler1.processEvent(); delayedEventHandler.processEvent(); }
sequenceBarrier.clearAlert(); cachedAvailableSequence = sequenceBarrier.waitFor(nextSequence);
/** * 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; }
sequenceBarrier.clearAlert();
@Override public boolean hasMessages() { return head != tail || sequence.get() < sequenceBarrier.getCursor(); }
private long getAvailableConsumeCursor() throws AlertException, InterruptedException, TimeoutException { final long nextSequence = _consumer.get() + 1; return _barrier.waitFor(nextSequence); }
sequenceBarrier.clearAlert(); cachedAvailableSequence = sequenceBarrier.waitFor(nextSequence);
private int applyWaitMethod(final SequenceBarrier barrier, int counter) throws AlertException { barrier.checkAlert(); if (counter > 100) { --counter; } else if (counter > 0) { --counter; Thread.yield(); } else { LockSupport.parkNanos(sleepTimeNs); } return counter; } }
@Override public void halt() { running.set(false); sequenceBarrier.alert(); }
/** * It is ok to have another thread rerun this method after a halt(). * * @throws IllegalStateException if this object instance is already running in a thread */ @Override public void run() { if (running.compareAndSet(IDLE, RUNNING)) { sequenceBarrier.clearAlert(); } else if (running.get() == RUNNING) { throw new IllegalStateException("Thread is already running"); } nextSequence = sequence.get() + 1L; }
public void consumeBatch(EventHandler<Object> handler) { consumeBatchToCursor(_barrier.getCursor(), handler); }