JUC下的atomic包（java.util.concurrent.atomic，i++线程安全问题）

1. java.util.concurrent.atomic包

在Java5.0后，java.util.concurrent.atomic包下提供了常用的支持原子性操作的原子处理类，这些原子类内部提供的操作方法都是线程安全的volatile原子操作。主要用于高并发环境下的高效程序处理。里面的值具有以下特性：

• volatile保证内存可见性
• CAS（Compare And Swap）算法保证数据的原子性

以AtomicInteger为例看源码：

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
                (AtomicInteger.class.getDeclaredField("value"));
        } catch (Exception ex) { throw new Error(ex); }
    }

    private volatile int value;

    //获取当前的值
    public final int get() {
        return value;
    }
    
    //取当前的值，并设置新的值
    public final int getAndSet(int newValue) {
        return unsafe.getAndSetInt(this, valueOffset, newValue);
    }
     
    //
    public final boolean compareAndSet(int expect, int update) {
        return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
    }
	
    //获取当前的值，并自增	
    public final int getAndIncrement() {
        return unsafe.getAndAddInt(this, valueOffset, 1);
    }

    //自增，并获取当前的值
    public final int incrementAndGet() {
        return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
    }

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

    ......
    
}

2. CAS算法

CAS算法是硬件（操作系统）对于并发操作共享数据的一种支持；

CAS算法包含三个操作数：内存值V、预估值A、更新值B，当且仅当 V==A 时，V=B，否则，将不做任何操作。

注：为什么CAS算法比同步锁的效率高呢？
CAS算法相当于一种乐观锁，当不会成功时，它不会放弃CPU的使用权，会不断尝试。比synchronized实现的悲观锁效率高。

3. 用AtomicInteger保证i++线程安全

i++的原子性问题：i++的操作实际上分为三个步骤：读—>改—>写
第一步：读取i
第二步：i+1
第三步：将增值加后的i赋值给之前的i

可以看出，i++的操作是非原子性的，存在线程安全性问题，可以用JUC包下的AtomicInteger类来解决这个问题，如下：

public class AtomicTest implements Runnable{

    private AtomicInteger i = new AtomicInteger();

    public int getI(){
        return i.incrementAndGet();//替代i++
    }

    @Override
    public void run(){
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(getI());
    }

    public static void main(String[] args) {
        AtomicTest atomicTest = new AtomicTest();

        for(int i=0;i<10;i++){
            new Thread(atomicTest).start();
        }
    }
}

其中一次的输出结果：

1
2
3
9
8
7
6
4
5
10

注：AtomicXXX的多个方法并不保证原子性，即只保证单个方法调用的原子性；