聊聊多线程（四）线程安全之AtomicInteger类

超详细的Java知识点路线图

---

线程安全的概念

多个线程访问同一个对象时，如果不用考虑这些线程在运行时环境下的调度和交替执行，也不需要进行额外的同步，或者在调用方进行任何其他操作，调用这个对象的行为都可以获得正确的结果，那么这个对象就是线程安全的。

线程安全问题

假设我们的网站要统计用户人数，我们需要通过变量的自增来实现：count++; 这个操作存在线程安全问题：

    static int count = 0;
	
	public static void main(String[] args) {
		for(int i = 0;i < 10000;i++){
			count++;
		}
		System.out.println("count = " + count);
	}

上面单线程的环境下，无论执行多少次，结果都是10000。修改代码如下：

	static int count = 0;
	
	public static void main(String[] args) {
		for(int i = 0;i < 10000;i++){
			new Thread(()->{count++;}).start();
		}
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("count = " + count);
	}

这部分代码，模拟10000个用户，每个用户都在自己的线程中对count执行自增,执行多次后发现，最后count的值出现9999或9997的结果。也就是某些用户的自增数据出现了丢失，那么为什么会出现这种情况呢？因为count++是非线程安全的！

问题分析

count++的操作分为三步：

1. 读取count的值
2. 计算count+1的值
3. 把新值存入count
   假设count值为100，两个线程A和B都执行了操作1，再同时执行操作2，A先进行操作3，这时count值为101，B再执行操作3，之前B读取的值是100，执行完操作3后B的结果还是101，这样数据出现了问题。因为上面的操作不是原子的，可以分开执行。

AtomicInteger 原子整型类

AtomicInteger出现解决了上面的问题，使用它来执行统计：

	static AtomicInteger at = new AtomicInteger(0);
	
	public static void main(String[] args) {
		for(int i = 0;i < 10000;i++){
			new Thread(()->{at.incrementAndGet();}).start();
		}
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("count = " + at.get());
	}

无论执行多少次，结果都是10000

AtomicInteger解析

那么AtomicInteger是如何实现原子操作的呢？我们看看它的源码：

public class AtomicInteger extends Number implements java.io.Serializable {
    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;
    ...

首先Unsafe是Java的一个工具类，通过非安全的操作让Java实现类似C、C++等语言的对内存等硬件的功能。这里使用Unsafe获得的是AtomicInteger的value值在堆内存中的偏移量，这个偏移量是实现原子操作的关键。

private volatile int value;

value是保存的整数值，这个属性前面的关键字volatile很重要。

volatile关键字

volatile相当于synchronized的弱实现，也就是说volatile实现了类似synchronized的语义，却又没有锁机制。它确保对volatile字段的更新以可预见的方式告知其他的线程。

volatile包含以下语义：

• Java 存储模型不会对valatile指令的操作进行重排序：这个保证对volatile变量的操作时按照指令的出现顺序执行的。
  
• volatile变量不会被缓存在寄存器中（只有拥有线程可见）或者其他对CPU不可见的地方，每次总是从主存中读取volatile变量的结果。也就是说对于volatile变量的修改，其它线程总是可见的，并且不是使用自己线程栈内部的变量。也就是在happens-before法则中，对一个valatile变量的写操作后，其后的任何读操作理解可见此写操作的结果。

简而言之volatile 的作用是当一个线程修改了变量时，另一个线程可以读取到这个修改后的值。

自增自减操作

• incrementAndGet方法执行自增操作，相当于count++;
• decrementAndGet方法执行自减操作，相当于count–;

    public final int incrementAndGet() {
        return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
    }

    public final int decrementAndGet() {
        return unsafe.getAndAddInt(this, valueOffset, -1) - 1;
    }
    
getAndAddInt的实现
public final int getAndAddInt(Object o, long offset, int delta) {
    int v;
    do {
        v = getIntVolatile(o, offset);
    } while (!compareAndSwapInt(o, offset, v, v + delta));
    return v;
}
public native int     getIntVolatile(Object o, long offset);
public final native boolean compareAndSwapInt(Object o, long offset,
                                              int expected,
                                              int x);

getAndAddInt实现了CAS算法（比较与交换，Compare and swap）是一种有名的无锁算法。CAS的语义是“我认为V的值应该为A，如果是，那么将V的值更新为B，否则不修改并告诉V的值实际为多少”，CAS是项乐观锁技术，当多个线程尝试使用CAS同时更新同一个变量时，只有其中一个线程能更新变量的值，而其它线程都失败，失败的线程并不会被挂起，而是被告知这次竞争中失败，并可以再次尝试。CAS有3个操作数，内存值V，旧的预期值A，要修改的新值B。当且仅当预期值A和内存值V相同时，将内存值V修改为B，否则什么都不做。

AtomicInteger的CAS操作就是:通过内存偏移量offset将数据取出，和expected期待值进行比较，如果相等就代表此过程中没有其他线程修改此值，那么就把存储中的值修改掉，否则就放弃修改。

总结

1. AtomicInteger能够实现整型数据的原子操作，在多线程并发的环境下能保证数据安全，而且内部使用乐观锁实现，比使用锁机制的并发性能高
2. volatile保证了一个线程修改数据时，其它线程也能看到数据的修改
3. CAS操作保证了数据修改的安全性

---

大家如果需要学习其他Java知识点，戳这里 超详细的Java知识点汇总