@Override boolean casValue(AbstractFuture<?> future, Object expect, Object update) { return valueUpdater.compareAndSet(future, expect, update); } }
@SuppressWarnings({ "rawtypes", "unchecked" }) private void addOnComplete(Object action) { for (;;) { Object[] existing = ONCOMPLETE.get(this); Object[] updated = new Object[existing.length + 1]; System.arraycopy(existing, 0, updated, 0, existing.length); updated[existing.length] = action; if (ONCOMPLETE.compareAndSet(this, existing, updated)) { return; } } }
@SuppressWarnings("unchecked") protected final MpscLinkedQueueNode<E> getAndSetTailRef(MpscLinkedQueueNode<E> tailRef) { // LOCK XCHG in JDK8, a CAS loop in JDK 7/6 return (MpscLinkedQueueNode<E>) UPDATER.getAndSet(this, tailRef); } }
public void setTimeoutsHolder(TimeoutsHolder timeoutsHolder) { TIMEOUTS_HOLDER_FIELD.set(this, timeoutsHolder); }
@Override protected FIELD getActualValue(OBJECT obj) { return actual.get(obj); } }
@Override void putThread(Waiter waiter, Thread newValue) { waiterThreadUpdater.lazySet(waiter, newValue); }
@Test public void syncDisposeIdempotent() { final WorkerTask run = new WorkerTask(() -> {}, null); WorkerTask.THREAD.set(run, Thread.currentThread()); run.dispose(); assertThat((Future<?>) WorkerTask.FUTURE.get(run)).isEqualTo(WorkerTask.SYNC_CANCELLED); run.dispose(); assertThat((Future<?>) WorkerTask.FUTURE.get(run)).isEqualTo(WorkerTask.SYNC_CANCELLED); run.run(); assertThat((Future<?>) WorkerTask.FUTURE.get(run)).isEqualTo(WorkerTask.SYNC_CANCELLED); }
@Override public void operationComplete() { // We now have a new ledger where we can write synchronized (pendingMarkDeleteOps) { flushPendingMarkDeletes(); // Resume normal mark-delete operations STATE_UPDATER.set(ManagedCursorImpl.this, State.Open); } }
public TimeoutsHolder getTimeoutsHolder() { return TIMEOUTS_HOLDER_FIELD.get(this); }
@Override void putNext(Waiter waiter, Waiter newValue) { waiterNextUpdater.lazySet(waiter, newValue); }
@Override void compareAndSetSeenExceptions( AggregateFutureState state, Set<Throwable> expect, Set<Throwable> update) { seenExceptionsUpdater.compareAndSet(state, expect, update); }
static <T> void addSequence(final T holder, final AtomicReferenceFieldUpdater<T, Sequence[]> updater, final Sequence sequence) { Sequence[] updatedSequences; Sequence[] currentSequences; do { currentSequences = updater.get(holder); updatedSequences = copyOf(currentSequences, currentSequences.length + 1); updatedSequences[currentSequences.length] = sequence; } while (!updater.compareAndSet(holder, currentSequences, updatedSequences)); }
public Object takePartitionKeyLock() { // shortcut, much faster than getAndSet if (partitionKeyLock == null) { return null; } return PARTITION_KEY_LOCK_FIELD.getAndSet(this, null); }
protected ConnectionHandler(HandlerState state, Backoff backoff, Connection connection) { this.state = state; this.connection = connection; this.backoff = backoff; CLIENT_CNX_UPDATER.set(this, null); }
@Override public boolean isDisposed() { Composite o = PARENT.get(this); return o == DISPOSED || o == DONE; }
final void setNext(final MpscLinkedQueueNode<T> newNext) { // Similar to 'next = newNext', but slightly faster (storestore vs loadstore) // See: http://robsjava.blogspot.com/2013/06/a-faster-volatile.html nextUpdater.lazySet(this, newNext); }
@Override boolean casListeners(AbstractFuture<?> future, Listener expect, Listener update) { return listenersUpdater.compareAndSet(future, expect, update); }
@SuppressWarnings({ "unchecked", "rawtypes" }) private CompletionStage<List<T>> publicStage() { CompletionStage stage = UPDATER.get(this); if (stage == null) { stage = createPublicStage(this.executions); UPDATER.compareAndSet(this, null, stage); } return stage; }