@Override public boolean add(T t) { while (!offer(t)); return true; }
@Override public Object[] toArray() { T t = get(); if (t == null) { return new Object[0]; } return new Object[]{t}; }
/** * Block with wait/notifyAll semantics * @param spinTimeout the spin timeout * @param yieldTimeout the yield timeout * @param units the time unit * @return the wait strategy */ public static WaitStrategy phasedOffLiteLock(long spinTimeout, long yieldTimeout, TimeUnit units) { return phasedOff(spinTimeout, yieldTimeout, units, liteBlocking()); }
@Override public int getBufferSize() { return Queues.capacity(this.queue); }
/** * Block with wait/notifyAll semantics * @param spinTimeout the spin timeout * @param yieldTimeout the yield timeout * @param units the time unit * @return the wait strategy */ public static WaitStrategy phasedOffLock(long spinTimeout, long yieldTimeout, TimeUnit units) { return phasedOff(spinTimeout, yieldTimeout, units, blocking()); }
/** * Block by parking in a loop * @param spinTimeout the spin timeout * @param yieldTimeout the yield timeout * @param units the time unit * @return the wait strategy */ public static WaitStrategy phasedOffSleep(long spinTimeout, long yieldTimeout, TimeUnit units) { return phasedOff(spinTimeout, yieldTimeout, units, parking(0)); }
@Override protected void doError(Throwable t) { writeWait.signalAllWhenBlocking(); //ringBuffer.markAsTerminated(); }
/** * Variation of the {@link #blocking()} that attempts to elide conditional wake-ups when the lock is uncontended. * Shows performance improvements on microbenchmarks. However this wait strategy should be considered experimental * as I have not full proved the correctness of the lock elision code. * @return the wait strategy */ public static WaitStrategy liteBlocking() { return new LiteBlocking(); }
/** * Blocking strategy that uses a lock and condition variable for consumer waiting on a barrier. * * This strategy can be used when throughput and low-latency are not as important as CPU resource. * @return the wait strategy */ public static WaitStrategy blocking() { return new Blocking(); }
@Override public T remove() { return getAndSet(null); }
@Override protected void doComplete() { writeWait.signalAllWhenBlocking(); //ringBuffer.markAsTerminated(); }
@Override public int size() { return get() == null ? 0 : 1; }
/** * Alert the ringbuffer consumers of a status change and stay in this status until cleared. */ void alert() { alerted = true; waitStrategy.signalAllWhenBlocking(); }
@Override public T element() { return get(); }
@Override public void signalAllWhenBlocking() { fallbackStrategy.signalAllWhenBlocking(); }
/** * Signal the ringbuffer consumers. */ void signal() { waitStrategy.signalAllWhenBlocking(); }