org.jgroups.blocks.atomic.SyncCounter Maven / Gradle / Ivy

Go to download

Show more of this group Show more artifacts with this name
Show all versions of wildfly-client-all

This artifact provides a single jar that contains all classes required to use remote EJB and JMS, including all dependencies. It is intended for use by those not using maven, maven users should just import the EJB and JMS BOM's instead (shaded JAR's cause lots of problems with maven, as it is very easy to inadvertently end up with different versions on classes on the class path).

There is a newer version: 34.0.0.Final

Show newest version

package org.jgroups.blocks.atomic;

import org.jgroups.annotations.Experimental;
import org.jgroups.util.LongSizeStreamable;
import org.jgroups.util.Streamable;

/**
 * A synchronous counter interface
 *
 * @author Bela Ban
 * @author Pedro Ruivo
 * @since 5.2
 */
public interface SyncCounter extends BaseCounter {

    /**
     * Gets the current value of the counter
     *
     * @return The current value
     */
    long get();

    /**
     * Sets the counter to a new value
     *
     * @param new_value The new value
     */
    void set(long new_value);


    /**
     * Atomically updates the counter using a CAS operation
     *
     * @param expect The expected value of the counter
     * @param update The new value of the counter
     * @return True if the counter could be updated, false otherwise
     */
    default boolean compareAndSet(long expect, long update) {
        return compareAndSwap(expect, update) == expect;
    }

    /**
     * Atomically updates the counter using a compare-and-swap operation.
     *
     * @param expect The expected value of the counter
     * @param update The new value of the counter
     * @return The previous value of the counter
     */
    long compareAndSwap(long expect, long update);

    /**
     * Atomically increments the counter and returns the new value
     *
     * @return The new value
     */
    default long incrementAndGet() {
        return addAndGet(1L);
    }

    /**
     * Atomically decrements the counter and returns the new value
     *
     * @return The new value
     */
    default long decrementAndGet() {
        return addAndGet(-1L);
    }


    /**
     * Atomically adds the given value to the current value.
     *
     * @param delta the value to add
     * @return the updated value
     */
    long addAndGet(long delta);

    /**
     * Atomically updates the counter's value.
     * 
     * Both {@link CounterFunction} and return value must implement {@link Streamable} to be sent over the network. The function should not block thread since it can cause deadlocks neither invoke any operation over the {@link SyncCounter}.
     * 
     * The {@link CounterView} is a copy of the counter's value and the last {@link CounterView#set(long)} will be applied to the counter.
     *
     * @param updateFunction The update {@link CounterFunction}.
     * @param             The return value type.
     * @return The function's return value.
     * @see CounterFunction
     * @see CounterView
     * @see LongSizeStreamable
     */
    @Experimental
    default  T update(CounterFunction updateFunction) {
        throw new UnsupportedOperationException();
    }

    @Override
    default SyncCounter sync() {
        return this;
    }
}