AtomicInteger类的理解与使用

 

 

package TestAtomicInteger;
 
import java.util.concurrent.atomic.AtomicInteger;
 
class MyThread implements Runnable {
//    static  int i = 0;
     static AtomicInteger ai=new AtomicInteger(0);
      
 
    public void run() {
        for (int m = 0; m < 1000000; m++) {
            ai.getAndIncrement();
        }
    }
};
 
public class TestAtomicInteger {
    public static void main(String[] args) throws InterruptedException {
        MyThread mt = new MyThread();
 
        Thread t1 = new Thread(mt);
        Thread t2 = new Thread(mt);
        t1.start();
        t2.start();
        Thread.sleep(500);
        System.out.println(MyThread.ai.get());
    }
}

可以发现结果都是2000000，也就是说AtomicInteger是线程安全的。

这里，我们来看看AtomicInteger是如何使用非阻塞算法来实现并发控制的。

AtomicInteger的关键域只有一下3个：

// setup to use Unsafe.compareAndSwapInt for updates  
private static final Unsafe unsafe = Unsafe.getUnsafe();  
private static final long valueOffset;  
private volatile int value; 

 这里， unsafe是java提供的获得对对象内存地址访问的类，注释已经清楚的写出了，它的作用就是在更新操作时提供“比较并替换”的作用。实际上就是AtomicInteger中的一个工具。

valueOffset是用来记录value本身在内存的编译地址的，这个记录，也主要是为了在更新操作在内存中找到value的位置，方便比较。

注意：value是用来存储整数的时间变量，这里被声明为volatile，就是为了保证在更新操作时，当前线程可以拿到value最新的值（并发环境下，value可能已经被其他线程更新了）。

这里，我们以自增的代码为例，可以看到这个并发控制的核心算法：

public class AtomicInteger extends Number implements java.io.Serializable {
    ......
    // setup to use Unsafe.compareAndSwapInt for updates
    private static final Unsafe unsafe = Unsafe.getUnsafe();
    private static final long valueOffset;
    private volatile int value;

    ......
            ......

    /**
     * Gets the current value.
     *
     * @return the current value
     */
    public final int get() {
        return value;
    }

    ......

    /**
     * Atomically increments by one the current value.
     * @return the updated value
     */
    public final int incrementAndGet() {

        // 一直循环的目的是为了“预期值”与“真实值”不一致的情况下，
        // 能够重新进行+1计算

        for (;;) {
            // 取得/重新取得 当前的value值
            int current = get();
            // 将当前值+1
            int next = current + 1;

            /**
                 这是最关键的，使用JDK中实现的CAS机制
                 对当前值和预期值进行比较
                 如果当前值和预期的(CAS算法需要你额外给出一个期望值,也就是你认为现在的变量应该是什么样子的,如果变量
                 不是你想象的那样,那就说明已经被别的线程修改过了,你就需要重新读取,再次尝试修改即可)不一样，
                 说明有某一个其他线程完成了值的更改那么进行下一次循环，进行重新操作（因为之前的操作结果就不对了）
                 循环的内容是

                 1.取得当前值

                 2.计算+1后的值

                 3.如果当前值没有被覆盖的话,设置那个+1后的值

                 4.如果设置失败(如:线程A取出当前值为1 按理说预期要修改的值也为1 但在此之前线程B已经执行过+1操作
                 结果期望值已经变成了2 1!=2 所以失败 ),
                 再从1开始(此时如果没有其他线程修改该变量的话,那么当前值是2 期望值是2) 计算成功

                 CAS的全称是Compare And Swap 即比较交换，其算法核心思想如下

                 执行函数：CAS(V,E,N)

                 其包含3个参数

                 V表示要更新的变量

                 E表示预期值

                 N表示新值

                 如果V值等于E值，则将V的值设为N。若V值和E值不同，则说明已经有其他线程做了更新，则当前线程什么都不做。通俗的理解就是CAS操作需要我们提供一个期望值，当期望值与当前线程的变量值相同时，说明还没线程修改该值，当前线程可以进行修改，也就是执行CAS操作，但如果期望值与当前线程不符，则说明该值已被其他线程修改，此时不执行更新操作，但可以选择重新读取该变量再尝试再次修改该变量，也可以放弃操作
             */
            //已知当前内存里面的值current(即期望值)和预期要修改成的值传入
            if (compareAndSet(current, next))
                return next;
        }
    }

    ......

    /**
     * JDK文档对该方法的说明如下：如果当前状态值等于预期值，则以原子方式将同步状态设置为给定的更新值。
     *
     */
    public final boolean compareAndSet(int expect, int update) {
        /**
         首先可以看到AtomicInteger类在域中声明了这两个私有变量unsafe和valueOffset。
         其中unsafe实例采用Unsafe类中静态方法getUnsafe()得到，
         但是这个方法如果我们写的时候调用会报错，因为这个方法在调用时会判断类加载器，
         我们的代码是没有“受信任”的，而在jdk源码中调用是没有任何问题的；
         valueOffset这个是指类中相应字段在该类的偏移量，
         在这里具体即是指value这个字段在AtomicInteger类的内存中相对于该类首地址的偏移量。

         // setup to use Unsafe.compareAndSwapInt for updates
         private static final Unsafe unsafe = Unsafe.getUnsafe();
         private static final long valueOffset;// 注意是静态的

         static {
         try {
             valueOffset = unsafe.objectFieldOffset
             (AtomicInteger.class.getDeclaredField("value"));// 反射出value属性，获取其在内存中的位置
         } catch (Exception ex) {
             throw new Error(ex);
             }
         }

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

         比较并设置，这里利用Unsafe类的JNI方法实现，使用CAS指令，可以保证读-改-写是一个原子操作。
         compareAndSwapInt有4个参数，
         this - 当前AtomicInteger对象，
         Offset - value属性在内存中的位置(需要强调的是:不是value值在内存中的位置,是value属性在内存中的位置)，
         expect - 预期值，update - 新值，根据上面的CAS操作过程，
         当内存中的value值等于expect值时，则将内存中的value值更新为update值，并返回true，否则返回false。
         在这里我们有必要对Unsafe有一个简单点的认识，从名字上来看，不安全，确实，这个类是用于执行低级别的、
         不安全操作的方法集合，这个类中的方法大部分是对内存的直接操作，所以不安全，但当我们使用反射、并发包时，都间接的用到了Unsafe。
         */
        return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
    }
}

再看unsafe.compareAndSwapInt(this, valueOffset, expect, update);源码：

可以发现期望值是我们 当时取得内存中的 private volatile int value;得到的 有可能已经被B线程更改,当前值是根据反射value属性字段 得到内存地址  得到的真实当前值

/**
 首先可以看到AtomicInteger类在域中声明了这两个私有变量unsafe和valueOffset。
 其中unsafe实例采用Unsafe类中静态方法getUnsafe()得到，
 但是这个方法如果我们写的时候调用会报错，因为这个方法在调用时会判断类加载器，
 我们的代码是没有“受信任”的，而在jdk源码中调用是没有任何问题的；
 valueOffset这个是指类中相应字段在该类的偏移量，
 在这里具体即是指value这个字段在AtomicInteger类的内存中相对于该类首地址的偏移量。
*/

// setup to use Unsafe.compareAndSwapInt for updates
 private static final Unsafe unsafe = Unsafe.getUnsafe();
 private static final long valueOffset;// 注意是静态的

 static {
 try {
     valueOffset = unsafe.objectFieldOffset
     (AtomicInteger.class.getDeclaredField("value"));// 反射出value属性，获取其在内存中的位置
 } catch (Exception ex) {
     throw new Error(ex);
     }
 }

 public final boolean compareAndSet(int expect, int update) {
 return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
 }
/**
 比较并设置，这里利用Unsafe类的JNI方法实现，使用CAS指令，可以保证读-改-写是一个原子操作。
 compareAndSwapInt有4个参数，
 this - 当前AtomicInteger对象，
 Offset - value属性在内存中的位置(需要强调的是:不是value值在内存中的位置,是value属性在内存中的位置)，
 expect - 预期值，update - 新值，根据上面的CAS操作过程，
 当内存中的value值等于expect值时，则将内存中的value值更新为update值，并返回true，否则返回false。
 在这里我们有必要对Unsafe有一个简单点的认识，从名字上来看，不安全，确实，这个类是用于执行低级别的、
 不安全操作的方法集合，这个类中的方法大部分是对内存的直接操作，所以不安全，但当我们使用反射、并发包时，都间接的用到了Unsafe。
 */