说Atomic类之前，先聊一聊volatile。
对volatile的第一印象就是可见性。所谓可见性，就是一个线程对共享变量的修改，别的线程能够感知到。
但是对于原子性，volatile是不能保证的。来看看自增操作的问题：
volatile int i; i++;
i++ 在多线程环境下，是不能保证最终的结果正确的。比如某个时刻，i=5，线程A读取了i的值，说时迟那时快，就在马上要执行++操作时，线程A突然就被切换走了；然后线程B也读取i的值，进行了++操作。这时i的值是6，即使线程A的工作内存中的缓存已经失效，线程A已经读取了i的值为5，不会再去读取，所以++操作后，i的值还是6。
关于volatile的底层实现，有好多文章分析的很透彻，这里不再赘述。
那么除了使用synchronized，还有没有其它的方式来解决上述问题呢？天空一声巨响，Atomic类闪亮登场！！！
先看看AtomicInteger类，其它类型包装成的Atomic类，请读者自习。
AtomicInteger i = new AtomicInteger(0); i.incrementAndGet();
用法相当简单，incrementAndGet 方法能实现原子性的自增操作。如何实现，看源码。
/**
* Atomically increments by one the current value.
*
* @return the updated value
*/
public final int incrementAndGet() {
return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
}
Unsafe类：
/**
* Atomically adds the given value to the current value of a field
* or array element within the given object <code>o</code>
* at the given <code>offset</code>.
*
* @param o object/array to update the field/element in
* @param offset field/element offset
* @param delta the value to add
* @return the previous value
* @since 1.8
*/
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;
}
/**
* Atomically update Java variable to <tt>x</tt> if it is currently
* holding <tt>expected</tt>.
* @return <tt>true</tt> if successful
*/
public final native boolean compareAndSwapInt(Object o, long offset,
int expected,
int x);
可以看到原子性的实现没有用synchronized，说明是非阻塞同步。最核心的方法是compareAndSwapInt，也就是所谓的CAS操作。
CAS操作依赖底层硬件的CAS指令，CAS指令有两个步骤：冲突检测和更新操作，但是这两个步骤合起来成为一个原子性操作。
CAS指令需要3个操作数：内存位置（V），旧的预期值（A），新值（B）。CAS指令执行时，首先比较内存位置V处的值和A的值是否相等（冲突检测），如果相等，就用新值B覆盖A（更新操作），否则，就什么也不做。所以，一般循环执行CAS操作，直到成功为止。
Unsafe类里面的compareAndSwapXXX 方法最后都会变成与硬件相关的CAS指令。从Unsafe这个类名就可以看出，作者不希望我们随便使用，因为是不安全的。为什么不安全呢，因为这个类可以直接操作内存；还有其他的一些底层操作，比如上篇文章提到的将线程挂起，就是调用了Unsafe类的park方法（感兴趣的，出门左拐）。
了解了CAS和Unsafe类，接着再说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"));
} catch (Exception ex) { throw new Error(ex); }
} private volatile int value;
value就是我们需要操作的真正int值，unsafe就是Unsafe类的单例，valueOffset在static语句块里面，被设置成了value变量在AtomicInteger类的实例对象里面的偏移量（可以看成内存地址）。这里对对象的内存布局如有疑问，同样出门一路左拐，找到那篇将Oop和Klass的文章。
也就是说，Atomic类通过循环进行CAS操作，直到成功，来实现非阻塞同步，进而变成原子操作。
在java.util.concurrent.atomic包下还有一些看上去比较奇怪的类，XXXFieldUpdater类，这玩意儿是用来干什么的呢？
一句话概括，就是亡羊补牢。比如说，你先自己写了一个类，定义了一个基础类型的变量。后来涉及到多线程，那么原来对该变量的一些操作就变得不安全。如果，你立马想到的是手动修改代码，那就太low了，破坏了设计模式里面比较重要的开闭原则，而且很多情况下，你是接触不到别人的源代码的。这个时候，XXXFieldUpdater类就派上用场了。这个时候，猜也能猜到，这个类肯定是通过反射的方式实现这个功能的。另外，有一点原来定义的继承类型变量，必须是volatile的。
直接上代码，看效果：
public class Test{
public volatile int a = 100;
// 多线程下不安全
public void incr() {
a++;
}
}
public class SafeTest{
private static AtomicIntegerFieldUpdater<Test> update = AtomicIntegerFieldUpdater.newUpdater(Test.class, "a");
private static Test test = new Test();
// 多线程下安全
public void incr() {
update.incrementAndGet(test);
}
}
update.incrementAndGet(test)无非也是调用了Unsafe类的CAS操作，核心方法是AtomicIntegerFieldUpdater.newUpdater(Test.class, "a")，看看源码：
@CallerSensitive
public static <U> AtomicIntegerFieldUpdater<U> newUpdater(Class<U> tclass,
String fieldName) {
return new AtomicIntegerFieldUpdaterImpl<U>
(tclass, fieldName, Reflection.getCallerClass());
} AtomicIntegerFieldUpdaterImpl(final Class<T> tclass,
final String fieldName,
final Class<?> caller) {
// 反射逻辑
final Field field;
final int modifiers;
try {
field = AccessController.doPrivileged(
new PrivilegedExceptionAction<Field>() {
public Field run() throws NoSuchFieldException {
return tclass.getDeclaredField(fieldName);
}
});
modifiers = field.getModifiers();
sun.reflect.misc.ReflectUtil.ensureMemberAccess(
caller, tclass, null, modifiers);
ClassLoader cl = tclass.getClassLoader();
ClassLoader ccl = caller.getClassLoader();
if ((ccl != null) && (ccl != cl) &&
((cl == null) || !isAncestor(cl, ccl))) {
sun.reflect.misc.ReflectUtil.checkPackageAccess(tclass);
}
} catch (PrivilegedActionException pae) {
throw new RuntimeException(pae.getException());
} catch (Exception ex) {
throw new RuntimeException(ex);
} Class<?> fieldt = field.getType();
if (fieldt != int.class)
throw new IllegalArgumentException("Must be integer type");
// 必须是volatile
if (!Modifier.isVolatile(modifiers))
throw new IllegalArgumentException("Must be volatile type"); this.cclass = (Modifier.isProtected(modifiers) &&
caller != tclass) ? caller : null;
this.tclass = tclass;
// 得到变量的偏移量，相当于内存地址
offset = unsafe.objectFieldOffset(field);
}
总的来说，原子性的实现是依赖于Unsafe类的CAS操作，直接修改内存里的值，既危险又刺激。我们甚至可以用Unsafe类来直接分配内存，要不试一试！！！
Unsafe类是单例，可以通过它的getUnsafe方法获取这个单例。
@CallerSensitive
public static Unsafe getUnsafe() {
Class<?> caller = Reflection.getCallerClass();
// 调用方的类的类加载器必须是启动类加载器
if (!VM.isSystemDomainLoader(caller.getClassLoader()))
throw new SecurityException("Unsafe");
return theUnsafe;
}
这个方法对调用方有限制，就是说你随随便便定义的类，调用这个方法是会报错的。但是Unsafe类既然已经被加载，我们可以通过反射的方式去获取里面的单例对象。
package test; import java.lang.reflect.Field; import sun.misc.Unsafe;
import sun.reflect.Reflection; class User {
private String name = "";
private int age = 0; public User() {
this.name = "test";
this.age = 25;
} @Override
public String toString() {
return name + ": " + age;
}
} public class Test {
public static void main(String[] args) throws NoSuchFieldException,
SecurityException, IllegalArgumentException, IllegalAccessException, InstantiationException {
// 通过反射得到theUnsafe对应的Field对象
Field field = Unsafe.class.getDeclaredField("theUnsafe");
// 设置该Field为可访问
field.setAccessible(true);
// 通过Field得到该Field对应的具体对象，传入null是因为该Field为static的
Unsafe unsafe = (Unsafe) field.get(null); // 直接分配相应大小的内存，不执行构造方法
User user = (User) unsafe.allocateInstance(User.class);
System.out.println(user); User userFromNormal = new User();
System.out.println(userFromNormal); }
}
这个例子演示了Unsafe直接为某个类的实例分配内存，注意是只分配内存，没有顺便调用构造方法。
运行结果：
null: 0
test: 25
当然，Unsafe类里面还有好多的底层操作，宝藏后面慢慢挖掘。就到这里吧！！！