/** * Tries to safely decrement a <em>positive</em> requested counter value, making sure the value does not drop below zero. * * @return {@code true} if the initial positive value has been decremented successfully, {@code false} in case the initial * counter value was already set to zero. */ public boolean tryDecrement() { return requested.getAndUpdate(val -> val > 0 ? val - 1 : 0) > 0; }
/** * Tries to safely decrement a <em>positive</em> requested counter value, making sure the value does not drop below zero. * * @return {@code true} if the initial positive value has been decremented successfully, {@code false} in case the initial * counter value was already set to zero. */ public boolean tryDecrement() { return requested.getAndUpdate(val -> { if (val == Long.MAX_VALUE) { return val; } else if (val > 0) { return val - 1; } else { return 0; } }) > 0; }
/** * In a non-blocking manner, try to acquire a single permit. * * @return original number of permits in this semaphore; if {@code 0} is returned, * the requester didn't obtain a permit. In case a {@link Long#MAX_VALUE} is returned, * the requester is informed that this semaphore is unbounded and that any further * acquire will be always successful. */ long tryAcquire() { return atomicLong.getAndUpdate(original -> { if (original == Long.MAX_VALUE) { // unbounded return original; } else { if (original == 0) { return 0; } else { return original - 1; } } }); }
@Override public Stopwatch start() { started.getAndUpdate(existing -> { if (existing == 0L) { // Has not yet been started ... existing = System.nanoTime(); if (uponStart != null) uponStart.run(); } return existing; }); return this; }
/** * Removes a section from the http data and updates the * indices of the remaining components. * * @param index The index of the component to remove. */ void removeComponent(int index) { Component component = components.get(index); components.remove(index); updateComponentOffsets(index); position.getAndUpdate((offset) -> offset - component.length); }
@Override public Stopwatch stop() { started.getAndUpdate(existing -> { if (existing != 0L) { // Is running but has not yet been stopped ... duration.add(Duration.ofNanos(System.nanoTime() - existing)); if (uponStop != null) uponStop.run(); return 0L; } return existing; }); return this; }
try { long readable = readableBytes(data); long offset = position.getAndUpdate(p -> readable); int length = new Long(readable - offset).intValue(); component = new Component(length, offset);
this.maxEventId.getAndUpdate(cur -> maxIdWritten > cur ? maxIdWritten : cur);
protected long nextId() { return id.getAndUpdate(prev -> { if ((prev & MAX_ID) == MAX_ID) { return prev ^ MAX_ID; } else { return prev + 1; } }); }
/** * Tries to safely decrement a <em>positive</em> requested counter value, making sure the value does not drop below zero. * * @return {@code true} if the initial positive value has been decremented successfully, {@code false} in case the initial * counter value was already set to zero. */ public boolean tryDecrement() { return requested.getAndUpdate(val -> val > 0 ? val - 1 : 0) > 0; }
@Override public long freshID() { return this.next.getAndUpdate(x -> { if (x == Long.MAX_VALUE) { throw new IllegalStateException("ID pool overflow!"); } return x + 1L; }); } }
@Override public Stopwatch start() { started.getAndUpdate(existing -> { if (existing == 0L) { // Has not yet been started ... existing = System.nanoTime(); if (uponStart != null) uponStart.run(); } return existing; }); return this; }
private void emitChunks(Subscriber<? super ByteBuf> downstream) { LongUnaryOperator decrementIfBackpressureEnabled = current -> current == Long.MAX_VALUE ? current : current > 0 ? current - 1 : 0; LongUnaryOperator incrementIfBackpressureEnabled = current -> current == Long.MAX_VALUE ? current : current + 1; while (requested.getAndUpdate(decrementIfBackpressureEnabled) > 0) { ByteBuf value = this.readQueue.poll(); if (value == null) { requested.getAndUpdate(incrementIfBackpressureEnabled); break; } emittedBytes.addAndGet(value.readableBytes()); emittedChunks.incrementAndGet(); downstream.onNext(value); } }
private void computeDecay(long count, double duration) { twoMinuteRate.getAndUpdate(prev -> Double.doubleToRawLongBits(decayingRate(count, Double.longBitsToDouble(prev), M2_ALPHA, duration))); fiveMinuteRate.getAndUpdate(prev -> Double.doubleToRawLongBits(decayingRate(count, Double.longBitsToDouble(prev), M5_ALPHA, duration))); tenMinuteRate.getAndUpdate(prev -> Double.doubleToRawLongBits(decayingRate(count, Double.longBitsToDouble(prev), M10_ALPHA, duration))); twentyMinuteRate.getAndUpdate(prev -> Double.doubleToRawLongBits(decayingRate(count, Double.longBitsToDouble(prev), M20_ALPHA, duration))); }
boolean updateCommitIndex(long newCommitIndex) { final long old = commitIndex.getAndUpdate(oldCommitIndex -> newCommitIndex); Preconditions.assertTrue(newCommitIndex >= old, () -> "newCommitIndex = " + newCommitIndex + " < old = " + old); return old != newCommitIndex; }
public boolean updateToMax(long newIndex, Consumer<Object> log) { final long old = index.getAndUpdate(oldIndex -> Math.max(oldIndex, newIndex)); log.accept(StringUtils.stringSupplierAsObject(() -> name + ": updateToMax " + old + " -> " + newIndex)); return old != newIndex; }
public void updateMaxJobId(JobId jobId) { maxJobIds.computeIfAbsent(jobId.getCcId(), key -> new AtomicLong()) .getAndUpdate(currentMaxId -> Math.max(currentMaxId, jobId.getId())); }
@Override public Stopwatch stop() { started.getAndUpdate(existing -> { if (existing != 0L) { // Is running but has not yet been stopped ... duration.add(Duration.ofNanos(System.nanoTime() - existing)); if (uponStop != null) uponStop.run(); return 0L; } return existing; }); return this; }
public boolean updateUnconditionally(LongUnaryOperator update, Consumer<Object> log) { final long old = index.getAndUpdate(update); final long newIndex = update.applyAsLong(old); log.accept(StringUtils.stringSupplierAsObject(() -> name + ": updateUnconditionally " + old + " -> " + newIndex)); return old != newIndex; }
private long report(String streamSegmentName, SegmentAggregates aggregates) { return aggregates.lastReportedTime.getAndUpdate(prev -> { if (System.currentTimeMillis() - prev > reportingDuration) { reporter.report(streamSegmentName, aggregates.getTargetRate(), aggregates.getScaleType(), aggregates.getStartTime(), aggregates.getTwoMinuteRate(), aggregates.getFiveMinuteRate(), aggregates.getTenMinuteRate(), aggregates.getTwentyMinuteRate()); return System.currentTimeMillis(); } return prev; }); }