源码阅读 AtomicInteger

灰太狼 2023-07-15 04:59 31阅读 0赞

[前些天发现了一个巨牛的人工智能学习网站，通俗易懂，风趣幽默，忍不住分享一下给大家。点击跳转到教程。][Link 1]

AtomicInteger 原子整数
    可以原子更新的int值。
    用于原子递增计数器等应用程序中，不能用作java.lang.Integer的替换。
    扩展了Number。
    
    # 1.继承关系：
    
       public class AtomicInteger extends Number implements java.io.Serializable 
            
        
    # 2. 属性、代码块：
    
        // Unsafe的实例
        private static final Unsafe unsafe = Unsafe.getUnsafe();
        // value字段的偏移量
        private static final long valueOffset;
    
        // 得 value 的偏移量
        static {
            try {
                valueOffset = unsafe.objectFieldOffset
                    (AtomicInteger.class.getDeclaredField("value"));
            } catch (Exception ex) { throw new Error(ex); }
        }
        
        // 用于存储 int 的值。
        private volatile int value;
    
        
    # 3.方法：
    
    
       // 构造
       public AtomicInteger(int initialValue) {
           value = initialValue;
       }
    
       public AtomicInteger() {
       }
    
       public final int get() {
           return value;
       }
    
       public final void set(int newValue) {
           value = newValue;
       }
    
       // set的延迟实现，不保证值的改变立即被其他线程看到。
       public final void lazySet(int newValue) {
           unsafe.putOrderedInt(this, valueOffset, newValue);
       }
    
       // 原子地设置为给定值并返回旧值。
       public final int getAndSet(int newValue) {
           return unsafe.getAndSetInt(this, valueOffset, newValue);
       }
    
       // compareAndSwapInt方法参数：this操作的对象；
       // valueOffset对象中字段的偏移量；
       // expect原来的值，即期望的值；update要修改的值；
       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 。
       // 参数：this操作的对象；valueOffset对象中字段的偏移量； 1 要增加的值。
       // 返回的是未自增前的值。
       public final int getAndIncrement() {
           return unsafe.getAndAddInt(this, valueOffset, 1);
       }
    
       // 原子性地自减 1 。 返回的是未自减前的值。
       public final int getAndDecrement() {
           return unsafe.getAndAddInt(this, valueOffset, -1);
       }
    
       // 原子地将给定值添加到当前值。
       public final int getAndAdd(int delta) {
           return unsafe.getAndAddInt(this, valueOffset, delta);
       }
    
       // 原子性地自增 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 addAndGet(int delta) {
           return unsafe.getAndAddInt(this, valueOffset, delta) + delta;
       }
    
       // 原子地用应用给定函数的结果更新当前值，并返回上一个值。
       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;
       }
    
       // 原子性地使用将给定函数应用于当前值和给定值的结果更新当前值，并返回上一个值。
       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;
       }
    
       // 转为字符串。
       public String toString() {
           return Integer.toString(get());
       }
    
       // 得int、long、float、double值。
       public int intValue() {
           return get();
       }
    
       public long longValue() {
           return (long)get();
       }
    
       public float floatValue() {
           return (float)get();
       }
    
       public double doubleValue() {
           return (double)get();
       }

其它 ：

int a =0;

return ++a ;  输出 1。

return a++ ;  输出 0。

这是非原子性的操作。

[Link 1]: https://www.captainai.net/jiangyu1013/