JUC AtomicInteger源码解析 JDK8

比眉伴天荒 2023-03-13 03:18 16阅读 0赞

# 前言 #

AtomicInteger类通过volatile语义加上CAS操作，使得对AtomicInteger的操作实现了一种非阻塞同步，从而保证了线程安全。非阻塞在于它没有使用synchronized或者Lock，而是循环加CAS，既然是循环执行，那么肯定没有阻塞线程，也就没有切换线程所带来的消耗。

[JUC框架 系列文章目录][JUC_]

# 成员 #

private static final long serialVersionUID = 6214790243416807050L;  //定好序列化版本
    
        // 获得Unsafe的单例
        private static final Unsafe unsafe = Unsafe.getUnsafe();
        private static final long valueOffset; //value这个域相对于对象的偏移量
    
        static { 
            try { 
                valueOffset = unsafe.objectFieldOffset  //获得对象的域的偏移，与之相对的是staticFieldOffset
                    (AtomicInteger.class.getDeclaredField("value"));//获得value的Field
            } catch (Exception ex) {  throw new Error(ex); }
        }
    
        private volatile int value;

*  AtomicInteger内部大量是用来了Unsafe对象，大家都知道java里面没有指针，因为指针这种东西很容易导致大家犯错，但java还是用`sun.misc.Unsafe`这个类开了一个后门，使得可以使用指针偏移操作。
 *  Unsafe构造器私有，且是一个单例模式，只能通过单例方法`getUnsafe`获得实例。
 *  在静态初始化块中，通过反射的`Field`和Unsafe的`objectFieldOffset`，获得了value这个域相对于AtomicInteger对象的地址偏移量。
 *  `value`域，是AtomicInteger对象的数据来源。它被设置为volatile的，使得对value的操作结果都具有可见性。（注意，不保证原子性，比如value++这样的复合操作）

# 常用操作 #

public final int get() { 
            return value;  //return操作是一个原子操作，具有原子性
        }
    
        public final void set(int newValue) { 
            value = newValue; //赋值操作是一个原子操作，具有原子性
        }

*  可见`get/set`没有加锁，但在多线程环境下，这两个函数也能保证线程安全。因为return操作和赋值操作都是原子操作，所以两个函数都有原子性了，且volatile的value又使得对value的操作结果都具有可见性。

public final void lazySet(int newValue) { 
            unsafe.putOrderedInt(this, valueOffset, newValue);
        }
        
    //unsafe.java
        /** Ordered/Lazy version of {@link #putIntVolatile(Object, long, int)} */
        public native void    putOrderedInt(Object o, long offset, int x);

*  简单地说，lazySet使得程序执行变快了，但损失了可见性，可见性直到有某个volatile write操作或同步操作才能恢复。
 *  volatile write操作会在该操作前添加 store-store内存屏障，在该操作之后添加 store-load内存屏障，但lazySet却省去了这个 store-load内存屏障。这样，lazySet操作不会与任何先前的写操作重新排序，但可以与后续操作重新排序（lazySet操作因为重排序，可能排在了 它的后续操作的后面，自然也就不能保证其他线程可见了）。

public final int getAndSet(int newValue) { 
            return unsafe.getAndSetInt(this, valueOffset, newValue);
        }
    
    //unsafe.java
        public final int getAndSetInt(Object o, long offset, int newValue) { 
            int v;
            do { 
                v = getIntVolatile(o, offset);
            } while (!compareAndSwapInt(o, offset, v, newValue));
            return v;
        }
    
        /** Volatile version of {@link #getInt(Object, long)} */
        public native int     getIntVolatile(Object o, long offset);
    
        /** * Atomically update Java variable to <tt>x</tt> if it is currently * holding <tt>expected</tt>. * @return <tt>true</tt> if successful */
        public final native boolean compareAndSwapInt(Object o, long offset,
                                                      int expected,
                                                      int x);

*  上来就直接调用了Unsafe的操作。Unsafe的getAndSetInt逻辑，利用了 循环和CAS操作（compareAndSwap）和volatile变量，使得更新操作不需要加锁就能完全，不过缺点是有可能会循环若干次才能成功。
 *  getIntVolatile使得线程总是获得变量的最新更新的值。
 *  compareAndSwapInt的前两个参数，根据指针`o`和指针偏移`offset`和int值所占字节数量4，可以读取出该对象中的value值是多少。如果通过指针偏移发现 对象的value值 和 `expected`相同，那么将 对象的value值 设为 `x`，并返回true；如果通过指针偏移发现 对象的value值 和 `expected`不相同，直接返回false。
 *  而循环配合compareAndSwapInt，则使得，只有当对象的value值 在`v = getIntVolatile(o, offset)`和`compareAndSwapInt(o, offset, v, newValue)`的执行过程之间没有被其他线程修改的情况下（有可能执行前者之后，线程就被切换出去了，然后线程重新开始执行时，值已经被修改了），才会设置新值成功。
 *  这个函数的缺点在于，有可能需要执行好多次循环，函数才能结束。

public final boolean compareAndSet(int expect, int update) { 
            return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
        }

*  compareAndSet函数相比上一个函数，没有循环了，粒度变小了。它只是让你执行一次CAS操作，结果成功或者失败。

public final boolean weakCompareAndSet(int expect, int update) { 
            return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
        }

*  compareAndSet函数的weak版，但实现和compareAndSet一模一样，只能说，源码作者还没来得及写它的不同实现呢。
 *  它可能会返回 虚假的失败，且不提供排序保证。

public final int getAndIncrement() { 
            return unsafe.getAndAddInt(this, valueOffset, 1);
        }
    
    	public final int getAndDecrement() { 
            return unsafe.getAndAddInt(this, valueOffset, -1);
        }
    
    	public final int getAndAdd(int delta) { 
            return unsafe.getAndAddInt(this, valueOffset, delta);
        }
        
    	public final int incrementAndGet() { 
            return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
        }
    
    	public final int decrementAndGet() { 
            return unsafe.getAndAddInt(this, valueOffset, -1) - 1;
        }
        
        public final int addAndGet(int delta) { 
            return unsafe.getAndAddInt(this, valueOffset, delta) + delta;
        }

*  这几个函数都调用`unsafe.getAndAddInt`，区别在于：
    
     *  getAndIncrement相当于`i++`，getAndAddInt刚好返回旧值。
     *  getAndDecrement相当于`i--`。
     *  getAndAdd相当于`i += n`，但是它却返回旧值。
     *  incrementAndGet相当于`++i`，返回 getAndAddInt的旧值再加1.
     *  decrementAndGet相当于`--i`，返回 getAndAddInt的旧值再减1.
     *  addAndGet相当于`i += n`，返回 getAndAddInt的旧值再加n。

# 其他操作 #

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

*  IntUnaryOperator是个函数式接口，看名字Unary就知道，它代表一个int的一元方程。
 *  如果当你需要根据旧值来更新新值，且需要将更新的逻辑包含在函数式接口中时，就需要使用该函数。
 *  注意，传入的IntUnaryOperator不应该有副作用，它应该只操作自己的局部变量。
 *  updateAndGet与前者的区别在于，它返回新值。

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;
        }
    
        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;
        }

*  同理，IntBinaryOperator是int的二元方程，所以还需要一个参数x。

public int intValue() { 
            return get();
        }
    
        public long longValue() { 
            return (long)get();
        }
    
        public float floatValue() { 
            return (float)get();
        }
    
        public double doubleValue() { 
            return (double)get();
        }

*  上面几个操作进行了数据类型转换。

# 参考资料 #

[AtomicInteger lazySet vs. set – stackoverflow][AtomicInteger lazySet vs. set _ stackoverflow]  
[what’s the difference between compareAndSet and weakCompareAndSet in AtomicReference? – stackoverflow][what_s the difference between compareAndSet and weakCompareAndSet in AtomicReference_ _ stackoverflow]

[JUC_]: https://blog.csdn.net/anlian523/article/details/106598910
[AtomicInteger lazySet vs. set _ stackoverflow]: https://stackoverflow.com/questions/1468007/atomicinteger-lazyset-vs-set
[what_s the difference between compareAndSet and weakCompareAndSet in AtomicReference_ _ stackoverflow]: https://stackoverflow.com/questions/36428044/whats-the-difference-between-compareandset-and-weakcompareandset-in-atomicrefer