Refine search
void doTerminate() { Runnable r = onTerminate.get(); if (r != null && onTerminate.compareAndSet(r, null)) { r.run(); } }
@Override public void dispose() { if (subscribers.get() != TERMINATED) { @SuppressWarnings("unchecked") InnerSubscriber[] ps = subscribers.getAndSet(TERMINATED); if (ps != TERMINATED) { current.compareAndSet(PublishSubscriber.this, null); SubscriptionHelper.cancel(upstream); } } }
AtomicReference<Object> cache = new AtomicReference<Object>(); Object cachedValue = new Object(); cache.set(cachedValue); //... time passes ... Object cachedValueToUpdate = cache.get(); //... do some work to transform cachedValueToUpdate into a new version Object newValue = someFunctionOfOld(cachedValueToUpdate); boolean success = cache.compareAndSet(cachedValue,cachedValueToUpdate);
public void start() { DateTime now = DateTime.now(); executionStartTime.compareAndSet(null, now); // always update last execution start time lastExecutionStartTime.set(now); taskContext.start(); }
void setFirst(Future<?> f) { for (;;) { Future<?> current = first.get(); if (current == CANCELLED) { f.cancel(runner != Thread.currentThread()); return; } if (first.compareAndSet(current, f)) { return; } } }
@Override public void dispose() { if (subscribers.get() != TERMINATED) { @SuppressWarnings("unchecked") InnerSubscriber[] ps = subscribers.getAndSet(TERMINATED); if (ps != TERMINATED) { current.compareAndSet(PublishSubscriber.this, null); SubscriptionHelper.cancel(s); } } }
public void start() { DateTime now = DateTime.now(); executionStartTime.compareAndSet(null, now); startNanos.compareAndSet(0, System.nanoTime()); startFullGcCount.compareAndSet(-1, gcMonitor.getMajorGcCount()); startFullGcTimeNanos.compareAndSet(-1, gcMonitor.getMajorGcTime().roundTo(NANOSECONDS)); // always update last execution start time lastExecutionStartTime.set(now); }
boolean add(CompletableDisposable inner) { for (;;) { CompletableDisposable[] a = observers.get(); if (a == TERMINATED) { return false; } int n = a.length; CompletableDisposable[] b = new CompletableDisposable[n + 1]; System.arraycopy(a, 0, b, 0, n); b[n] = inner; if (observers.compareAndSet(a, b)) { return true; } } }
@Override @SuppressWarnings({ "unchecked", "rawtypes" }) public void onNext(T t) { SwitchMapMaybeObserver<R> current = inner.get(); if (current != null) { current.dispose(); } MaybeSource<? extends R> ms; try { ms = ObjectHelper.requireNonNull(mapper.apply(t), "The mapper returned a null MaybeSource"); } catch (Throwable ex) { Exceptions.throwIfFatal(ex); upstream.dispose(); inner.getAndSet((SwitchMapMaybeObserver)INNER_DISPOSED); onError(ex); return; } SwitchMapMaybeObserver<R> observer = new SwitchMapMaybeObserver<R>(this); for (;;) { current = inner.get(); if (current == INNER_DISPOSED) { break; } if (inner.compareAndSet(current, observer)) { ms.subscribe(observer); break; } } }
@Override public void serialize(ComplexPayload record, DataOutputView target) throws IOException { try { if (currentOwnerThread.compareAndSet(null, Thread.currentThread())) { target.write(InstantiationUtil.serializeObject(record)); } else { throw new IllegalStateException("Concurrent access to type serializer detected!"); } } finally { currentOwnerThread.set(null); } }
boolean add(InnerCompletableCache inner) { for (;;) { InnerCompletableCache[] a = observers.get(); if (a == TERMINATED) { return false; } int n = a.length; InnerCompletableCache[] b = new InnerCompletableCache[n + 1]; System.arraycopy(a, 0, b, 0, n); b[n] = inner; if (observers.compareAndSet(a, b)) { return true; } } }
@Override @SuppressWarnings({ "unchecked", "rawtypes" }) public void onNext(T t) { SwitchMapSingleObserver<R> current = inner.get(); if (current != null) { current.dispose(); } SingleSource<? extends R> ss; try { ss = ObjectHelper.requireNonNull(mapper.apply(t), "The mapper returned a null SingleSource"); } catch (Throwable ex) { Exceptions.throwIfFatal(ex); upstream.dispose(); inner.getAndSet((SwitchMapSingleObserver)INNER_DISPOSED); onError(ex); return; } SwitchMapSingleObserver<R> observer = new SwitchMapSingleObserver<R>(this); for (;;) { current = inner.get(); if (current == INNER_DISPOSED) { break; } if (inner.compareAndSet(current, observer)) { ss.subscribe(observer); break; } } }
/** * Apply {@link #beforeCommit(Supplier) beforeCommit} actions, apply the * request headers/cookies, and write the request body. * @param writeAction the action to write the request body (may be {@code null}) * @return a completion publisher */ protected Mono<Void> doCommit(@Nullable Supplier<? extends Publisher<Void>> writeAction) { if (!this.state.compareAndSet(State.NEW, State.COMMITTING)) { return Mono.empty(); } this.commitActions.add(() -> Mono.fromRunnable(() -> { applyHeaders(); applyCookies(); this.state.set(State.COMMITTED); })); if (writeAction != null) { this.commitActions.add(writeAction); } List<? extends Publisher<Void>> actions = this.commitActions.stream() .map(Supplier::get).collect(Collectors.toList()); return Flux.concat(actions).then(); }
void setRest(Future<?> f) { for (;;) { Future<?> current = rest.get(); if (current == CANCELLED) { f.cancel(runner != Thread.currentThread()); return; } if (rest.compareAndSet(current, f)) { return; } } } }
@Override @SuppressWarnings({ "unchecked", "rawtypes" }) public void onNext(T t) { SwitchMapSingleObserver<R> current = inner.get(); if (current != null) { current.dispose(); } SingleSource<? extends R> ss; try { ss = ObjectHelper.requireNonNull(mapper.apply(t), "The mapper returned a null SingleSource"); } catch (Throwable ex) { Exceptions.throwIfFatal(ex); upstream.cancel(); inner.getAndSet((SwitchMapSingleObserver)INNER_DISPOSED); onError(ex); return; } SwitchMapSingleObserver<R> observer = new SwitchMapSingleObserver<R>(this); for (;;) { current = inner.get(); if (current == INNER_DISPOSED) { break; } if (inner.compareAndSet(current, observer)) { ss.subscribe(observer); break; } } }
/** * Apply {@link #beforeCommit(Supplier) beforeCommit} actions, apply the * response status and headers/cookies, and write the response body. * @param writeAction the action to write the response body (may be {@code null}) * @return a completion publisher */ protected Mono<Void> doCommit(@Nullable Supplier<? extends Mono<Void>> writeAction) { if (!this.state.compareAndSet(State.NEW, State.COMMITTING)) { return Mono.empty(); } this.commitActions.add(() -> Mono.fromRunnable(() -> { applyStatusCode(); applyHeaders(); applyCookies(); this.state.set(State.COMMITTED); })); if (writeAction != null) { this.commitActions.add(writeAction); } List<? extends Mono<Void>> actions = this.commitActions.stream() .map(Supplier::get).collect(Collectors.toList()); return Flux.concat(actions).then(); }
boolean add(CacheDisposable<T> inner) { for (;;) { CacheDisposable<T>[] a = observers.get(); if (a == TERMINATED) { return false; } int n = a.length; @SuppressWarnings("unchecked") CacheDisposable<T>[] b = new CacheDisposable[n + 1]; System.arraycopy(a, 0, b, 0, n); b[n] = inner; if (observers.compareAndSet(a, b)) { return true; } } }
@Override @SuppressWarnings({ "unchecked", "rawtypes" }) public void onNext(T t) { SwitchMapMaybeObserver<R> current = inner.get(); if (current != null) { current.dispose(); } MaybeSource<? extends R> ms; try { ms = ObjectHelper.requireNonNull(mapper.apply(t), "The mapper returned a null MaybeSource"); } catch (Throwable ex) { Exceptions.throwIfFatal(ex); upstream.cancel(); inner.getAndSet((SwitchMapMaybeObserver)INNER_DISPOSED); onError(ex); return; } SwitchMapMaybeObserver<R> observer = new SwitchMapMaybeObserver<R>(this); for (;;) { current = inner.get(); if (current == INNER_DISPOSED) { break; } if (inner.compareAndSet(current, observer)) { ms.subscribe(observer); break; } } }
/** * Atomically tries to set the given Disposable on the field if it is null or disposes it if * the field contains {@link #DISPOSED}. * @param field the target field * @param d the disposable to set * @return true if successful, false otherwise */ public static boolean trySet(AtomicReference<Disposable> field, Disposable d) { if (!field.compareAndSet(null, d)) { if (field.get() == DISPOSED) { d.dispose(); } return false; } return true; }
boolean add(BehaviorSubscription<T> rs) { for (;;) { BehaviorSubscription<T>[] a = subscribers.get(); if (a == TERMINATED) { return false; } int len = a.length; @SuppressWarnings("unchecked") BehaviorSubscription<T>[] b = new BehaviorSubscription[len + 1]; System.arraycopy(a, 0, b, 0, len); b[len] = rs; if (subscribers.compareAndSet(a, b)) { return true; } } }