一.从i++说起
i++这个看是简单的操作其实不是一个原子操作，它是由三步组成的。取出i的值，进行加一操作，写会计算后的值。在多线程竞争环境下，如果多个线程同时调用包含i++的一段代码，就可能出现错误（一个线程将另一个线程的修改覆盖的问题）。
当然可以使用synchronized重量级锁来进行代码块互斥访问。但就i++这一句代码来说还有更轻量级的方式，那就是原子类AtomicInteger的getAndIncrement()方法。
二.AtomicInteger
AtomicInteger位于java.util.concurrent.atomic包下。他提供了一种用法简单、性能高效、线程安全地更新一个Integer变量的方式。
2.1 AtomicInteger的用法
AtomicInteger a = new AtomicInteger(0);
a.getAndIncrement();
a.getAndDecrement();
a.compareAndSet(int expect,int update); //返回值true or false
a.getAndAdd(int delta);
2.2 原理——以getAndIncrement()为例
AtomicIntger实现的原子操作是基于Unsafe类CAS操作实现的。CAS是指Compare And Swap即比较并交换。只有当变量的实际值和我们传入的期望值一致时，才进行交换操作（用传入的新值替换旧值）。
Unsafe类提供了三种基本的CAS操作。分别是CAS更新int，CAS更新long，CAS更新Object（引用类型）。
/**
*解释一下参数含义，其它两个类似
*@param var1 要更新的变量，一个Integer变量
*@param var2 Integer对象中实际存储int值位置的偏移量(个人理解，欢迎指正)
*@param var4 期望值
*@param var5 更新为这个值
*方法语义：
* 如果var1这个Integer对象在其偏移var2位置的值等于var4,则将该值改为var5,否则不改。
* 以上为原子操作，不会被打断，要么和期望相同修改成功，要么不同修改失败。
*/
public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);
public final native boolean compareAndSwapLong(Object var1, long var2, long var4, long var6);
public final native boolean compareAndSwapObject(Object var1, long var2, Object var4, Object var5);
Unsafe类中基于基本的CAS操作又实现了getAndInt()等方法，可以无阻塞地实现原子更新操作，不需加锁，不涉及线程阻塞等。源码如下：
//Unsafe中getAndAddInt的定义，语义是在原变量上加上var4
public final int getAndAddInt(Object var1, long var2, int var4) {
int var5;
do {
//取出现有的值
var5 = this.getIntVolatile(var1, var2);
//计算处相加后的值，并进行CAS操作，如果失败说明现有值被修改，需要重新计算相加后的值。
//如果成功循环结束，返回相加操作之前的值
} while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));
return var5;
}
而AtomicInteger中的getAndAdd、getAndIncrement等方法就是直接调用了Unsafe.getAndAddInt方法：
//AtomicInteger中getAndAdd的定义
public final int getAndAdd(int delta) {
return unsafe.getAndAddInt(this, valueOffset, delta);
}
//AtomicInteger getAndIncrement定义
public final int getAndIncrement() {
return unsafe.getAndAddInt(this, valueOffset, 1);
}
看到这里就可以明白用AtomicInteger实现“i++”是如何做到线程安全的了。上文说道i++分为三步：取值，计算，写回。但若是写回时，原值已经被其它线程改变了，那这次的计算就不正确了。unsafe.getAndAddInt中，通过CAS操作避免了这种情况，如果写回时值改变了就重新取值，重新计算并写回，一直循环直到成功。
三.其它原子类的使用
java.util.concurrent.atomic包中除了AtomicIntger，还有很多其它原子类，它们的实现原理都可以追根溯源到unsafe的三个CAS操作，这里不做详细记录了，只类别各举一个例子简单记录一下它们的使用，详细的使用规则，可在用到时参考JDK API文档和JDK源码
3.1 原子更新基本类型
AtomicBoolean
AtomicInteger
AtomicLong
使用AtomicBoolean实现多线程下某一段代码只执行一次。
AtomicBoolean isHappen= new AtomicBoolean(false);
if(isHappen.compareAndSet(false,true)) {
//多线程下这一段代码也只会执行一次
do something、、
}
3.2原子更新数组
AtomicIntegerArray
AtomicLongArray
AtomicReferenceArray
AtomicIntegerArray API举例：
//初始化
AtomicIntegerArray ai = new AtomicIntegerArray(new int[]{1,2,3,4,5});
//以原子方式将输入值与数组中索引i的元素相加
int addAndGet(int i,int delta);
//如果当前值等于预期值，则以原子方式将数组位置i的元素设置成update值
boolean compareAndSet(int i,int expect,int update)；
3.3原子更新引用类型
AtomicReference
AtomicStampedRference
AtomicMarkableReference
ABA问题
ABA问题是指在进行CAS操作时可能变量已经变了，而且变了多次，但变化的结果和原来的一致，即又变回初始值了。这时其实已经变过了，但CAS认为它和旧值一样，就认为没有变，其实已经变过了。
AtomicStampedReference解决ABA问题
解决的办法就是记录版本号。AtomicReference只需记录一个T reference代表要操作的引用。而AtomicStampedReference使用一个Pair泛型类同时记录reference和stamp。进行CAS操作时比较的是这个pair。Pair中的reference和stamp都是final的，一旦初始化就不会被修改了。
使用AtomicStampedReference主要使用的是其compareAndSet方法.
public boolean compareAndSet(V expectedReference,
V newReference,
int expectedStamp,
int newStamp) {
Pair<V> current = pair;
return
//先判断期望值和当前值是否相同，不同也没有必要进行CAS了
expectedReference == current.reference &&
expectedStamp == current.stamp &&
//如果新值和当前值已经一样了，也不需更新了。
((newReference == current.reference &&
newStamp == current.stamp) ||
//进行CAS：用新值生成新的Pair，如果实际值和传入的当前值pair是同一个，则进行替换。
//底层使用unsafe的compareAndSwapObject方法比较引用类型
casPair(current, Pair.of(newReference, newStamp)));
}
3.4原子更新字段类
AtomicIntegerFieldUpdater
AtomicLongFieldUpdater
AtomicReferenceFieldUpdater
//可用于原子地更新User类的old字段。old字段必须是public volatile修饰的。
AtomicIntegerFieldUpdater<User> a =
AtomicIntegerFieldUpdater.newUpdater(User.class,"old");
User conan = new User("conan",10);
a.getAndIncrement(conan);
网友评论