源码：并发包-AtomicInteger的源码解析

深藏阁楼爱情的钟 2021-12-24 09:29 236阅读 0赞

花了一点时间看了一下源码，记录了一下，在这里把记录的东西贴出来，和前边的文章有一些区别

public class AtomicInteger extends Number implements java.io.Serializable {
        private static final long serialVersionUID = 6214790243416807050L;
    
        // setup to use Unsafe.compareAndSwapInt for updates
        private static final Unsafe unsafe = Unsafe.getUnsafe();
        private static final long valueOffset;
    
        static {
          try {
            valueOffset = unsafe.objectFieldOffset
                (java.util.concurrent.atomic.AtomicInteger.class.getDeclaredField("value"));
          } catch (Exception ex) { throw new Error(ex); }
        }
    
        private volatile int value;
    
        /**
         * 有值的构造对象
         */
        public AtomicInteger(int initialValue) {
          value = initialValue;
        }
    
        /**
         * 无值的构造函数
         */
        public AtomicInteger() {
        }
    
        /**
         * 获取值
         */
        public final int get() {
          return value;
        }
    
        /**
         * 设置值
         */
        public final void set(int newValue) {
          value = newValue;
        }
    
        /**
         * 这块在上一篇文章中已经介绍过
         */
        public final void lazySet(int newValue) {
          unsafe.putOrderedInt(this, valueOffset, newValue);
        }
    
        /**
         * 获取并设置新值
         */
        public final int getAndSet(int newValue) {
          return unsafe.getAndSetInt(this, valueOffset, newValue);
        }
    
        /**
         * var1是对象，var2是偏移量，var4是新值
         */
        public final int getAndSetInt(Object var1, long var2, int var4) {
          int var5;
          do {
            /**
             * 通过对象和偏移量读取不经过缓存的值
             * https://stackoverflow.com/questions/48615456/what-is-difference-between-getxxxvolatile-vs-getxxx-in-java-unsafe
             */
            var5 = this.getIntVolatile(var1, var2);
            /**
             * 不成功会一直重试，并把原来的值返回
             */
          } while(!this.compareAndSwapInt(var1, var2, var5, var4));
    
          return var5;
        }
    
        /**
         * 比对set
         */
        public final boolean compareAndSet(int expect, int update) {
          return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
        }
    
        /**
         * 前边文章有讲解
         */
        public final boolean weakCompareAndSet(int expect, int update) {
          return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
        }
    
        /**
         * 加1，返回的是旧的值
         */
        public final int getAndIncrement() {
          return unsafe.getAndAddInt(this, valueOffset, 1);
        }
    
        /**
         * 减1，返回的是旧的值
         */
        public final int getAndDecrement() {
          return unsafe.getAndAddInt(this, valueOffset, -1);
        }
    
        /**
         * 加1，返回的是新值
         */
        public final int incrementAndGet() {
          return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
        }
    
    
        /**
         * 减1，返回的是新值
         */
        public final int decrementAndGet() {
          return unsafe.getAndAddInt(this, valueOffset, -1) - 1;
        }
    
        /**
         * 增加的是固定的值，返回的是增加前的值
         */
        public final int getAndAdd(int delta) {
          return unsafe.getAndAddInt(this, valueOffset, delta);
        }
    
        /**
         * 这是上边这几个方法的原生方法
         */
        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;
        }
    
        /**
         * addAndGet方法，addAndGet方法内部使用一个死循环，先得到当前的值value，然后再把当前的值加一，加完之后使用cas原子操作让当前值加一处理正确。
         * 当然cas原子操作不一定是成功的，所以做了一个死循环，当cas操作成功的时候返回数据。这里由于使用了cas原子操作，所以不会出现多线程处理错误的问题。
         * 比如线程A得到current为1，线程B也得到current为1；线程A的next值为2，进行cas操作并且成功的时候，将value修改成了2；这个时候线程B也得到next值为2，
         * 当进行cas操作的时候由于expected值已经是2，而不是1了；所以cas操作会失败，下一次循环的时候得到的current就变成了2；也就不会出现多线程处理问题了
         */
        public final int addAndGet(int delta) {
          return unsafe.getAndAddInt(this, valueOffset, delta) + delta;
        }
    
    
        /**
         *这个方法是 Java 1.8 开始提供的，这个方法自身返回当前值。
         * 同时会把 updateFunction 的返回值设置为新值
         */
        public final int getAndUpdate(IntUnaryOperator updateFunction) {
          int prev, next;
          do {
            prev = get();
            next = updateFunction.applyAsInt(prev);
          } while (!compareAndSet(prev, next));
          return prev;
        }
    
        /**
         * 用法多线程环境下安全更新Integer i = ai.updateAndGet(x -> 5);
         */
        public final int updateAndGet(IntUnaryOperator updateFunction) {
          int prev, next;
          do {
            prev = get();
            next = updateFunction.applyAsInt(prev);
          } while (!compareAndSet(prev, next));
          return next;
        }
    
        /**
         * 1.8加入,多线程环境下安全更新  将原子值和传入的参数组合
         * !compareAndSet(prev, next)这是一个竞态的条件，满足的时候才会更新
         * compareAndSet相当于是原语的，原子操作
         * 返回的是旧值
         */
        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;
        }
    
        /**
         * 1.8加入,多线程环境下安全更新  将原子值和传入的参数组合
         * !compareAndSet(prev, next)这是一个竞态的条件，满足的时候才会更新
         * compareAndSet相当于是原语的，原子操作
         * 返回的是新值
         */
        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;
        }
    
        /**
         * 转String
         */
        public String toString() {
          return Integer.toString(get());
        }
    
        /**
         * 获取值
         */
        public int intValue() {
          return get();
        }
    
        /**
         * 强转long
         */
        public long longValue() {
          return (long)get();
        }
    
        /**
         * 强转float
         */
        public float floatValue() {
          return (float)get();
        }
    
        /**
         * 强转double
         */
        public double doubleValue() {
          return (double)get();
        }