Source code learning: atomicinteger class code internal logic

1. AtomicInteger What is it?

An atom renewable int value . A description of the properties of atomic variables , see also java.util.concurrent.atomic Package specification .AtomicInteger For applications such as atomic up counters , Can not be used as Integer substitute . however , This class does extend Number, To allow uniform access to tools and utilities that handle number based classes .

2. Set to use CAS updated

setUp to use Unsafe.compareAndAwapInt for update

3. Calculate the offset

Check the fields declared public by the user permission acquisition , Then, according to the fields with permission , Get the offset of the system value Get one long The value of the offset of type

static {
    
        try {
    
            valueOffset = unsafe.objectFieldOffset
                (AtomicInteger.class.getDeclaredField("value"));
        } catch (Exception ex) {
     throw new Error(ex); }
    }

4. Lazy assignment

 /** * Eventually sets to the given value.  At last, the assignment operation is performed  * * @param newValue the new value * @since 1.6 */
    public final void lazySet(int newValue) {
    
        unsafe.putOrderedInt(this, valueOffset, newValue);
    }

5. getAndSet Get first and then assign （ involve CAS）

public final int getAndSetInt(Object var1, long var2, int var4) {
    
        int var5;
        do {
    
            var5 = this.getIntVolatile(var1, var2);
        } while(!this.compareAndSwapInt(var1, var2, var5, var4));

        return var5;
    }

First step ： Pass in a value to replace var5; Then calculate according to var1 and war2 adopt getIntVolatile To calculate the var5
The second step ： If compareAndSwapInt Comparison results and var5 equal , return var5

6. compareAndSet

   /** * Atomically sets the value to the given updated value * if the current value {@code ==} the expected value. * * @param expect the expected value * @param update the new value * @return {@code true} if successful. False return indicates that * the actual value was not equal to the expected value. */
    public final boolean compareAndSet(int expect, int update) {
    
        return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
    }

If the actual value to be updated and the expected value to be updated do not want to wait, return false, If the actual value to be updated is equal to the expected value, return true

7. Get and update values

First step ：

 /** * Atomically adds the given value to the current value. * * @param delta the value to add * @return the updated value */
    public final int addAndGet(int delta) {
    
        return unsafe.getAndAddInt(this, valueOffset, delta) + delta;
    }

The second step ：

 public final int getAndAddInt(Object var1, long var2, int var4) {
    
    int var5;
    do {
    
        var5 = this.getIntVolatile(var1, var2);
    } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));

    return var5;
}

If the original value var1 And offset var2 The resulting calculations and results var5 equal , to var5 Add the corresponding increment delta namely var4

8.getAndUpdate

public final int getAndUpdate(IntUnaryOperator updateFunction) {
    
        int prev, next;
        do {
    
            prev = get();
            next = updateFunction.applyAsInt(prev);
        } while (!compareAndSet(prev, next));
        return prev;
    }

Update the current value atomically with the result of applying a given function , Return the value before updating . This function should have no side effects , Because when an attempt to update fails due to thread contention , Will try the update again .

9.updateAndGet

 public final int updateAndGet(IntUnaryOperator updateFunction) {
    
        int prev, next;
        do {
    
            prev = get();
            next = updateFunction.applyAsInt(prev);
        } while (!compareAndSet(prev, next));
        return next;
    }

Update the current value atomically with the result of applying a given function , Returns the updated value . This function should have no side effects , Because when an attempt to update fails due to thread contention , Will try the update again .

10.getAndAccumulate

public final int getAndAccumulate(int x, IntBinaryOperator accumulatorFunction) {
    
        int prev, next;
        do {
    
            prev = get();
            next = accumulatorFunction.applyAsInt(prev, x);
        } while (!compareAndSet(prev, next));
        return prev;
    }

Update the current value atomically with the result of applying the given function to the current value and the given value , Return the value before update . This function should have no side effects , Because when an attempt to update fails due to thread contention , The function may be reapplied . The first argument to the function is the current value , The second parameter is the given update .

11. accumulateAndGet

public final int accumulateAndGet(int x, IntBinaryOperator accumulatorFunction) {
    
        int prev, next;
        do {
    
            prev = get();
            next = accumulatorFunction.applyAsInt(prev, x);
        } while (!compareAndSet(prev, next));
        return next;
    }

Update the current value atomically with the result of applying the given function to the current value and the given value , Returns the updated value . This function should have no side effects , Because when an attempt to update fails due to thread contention , The function may be reapplied . The first argument to the function is the current value , The second parameter is the given update .