Atomic：
Atomic包是java.util.concurrent下的另一个专门为线程安全设计的java的包，包含多个原子性操作的类。基本特性就是在多线程情况下，当多个线程想要同时操作这些类的某些实例方法时，具有排他性，也就是当某个线程在执行某个方法时，不会被其他线程打断，其他线程会在外部等待，一直等到该方法执行完毕，才由JVM从等待队列中选择另一个线程进入，这只是一种逻辑上的理解。实际上是借助硬件的相关指令来实现的，不会阻塞线程(只是在硬件级别去阻塞了)。可以对基本数据，数组中的基本数据，对类中的基本数据进行操作。原子变量类相当于一种泛化的volatile变量，能够支持原子的和有条件的读写操作。
我们先看一下传统的锁是怎样保证线程安全的
class LockDemo {
private int a;
public synchronized void setA(int b) {
this.a = b;
}
public synchronized int getA() {
return a;
}
public synchronized void addA() {
++a;
}
public synchronized void reduceA() {
--a;
}
}
其实这样的synchronized已经能满足我们日常的线程安全需求了，synchronized是基于代码阻塞的机制，也就是当某个线程占用资源时，其他线程是无法进入的，如果这个线程出现问题的时候，出现大量线程阻塞，CPU就会耗费大量资源来处理阻塞在外的这些线程，但是CPU的任务本不该如此，还极可能出现死锁等问题，对于这样的简单操作反而显得有些笨重，所以应该有更合适更高效的方法来处理这样的问题。所以就有了CAS
Compare and swap(CAS)
当前的处理器基本都支持CAS，这是一种基于硬件的处理，每一个CAS操作都包含三个运算符：内存地址V ， 一个期望值A和新值B，操作的时候如果这个地址上存放的值等于期望的值A，那么就赋值为B，如果没有，那么就不做任何操作。简而言之，你的值和我的期望值相等，就给你新值，否则不干活了。
我们自己可以简单的模拟一下CAS的实现
class CASDemo {
private int value;
public synchronized int getValue() {
return value;
}
public synchronized int cas(int expectValue , int newValue) {
int oldValue = value;
if(value == expectValue) {
value = newValue;
}
return oldValue;
}
}
class CASTest {
private CASDemo casDemo;
public int getValue () {
return casDemo.getValue();
}
public int add () {
int oldValue = casDemo.getValue();
while(casDemo.cas(oldValue , oldValue + 1) != oldValue) {
oldValue = casDemo.getValue();
}
return oldValue + 1;
}
}
看下Atomic包
看一下AtomicInteger类是怎么处理自增的处理的，也就是方法getAndIncrement()
这里调用了一个叫做Unsafe类的方法，这个类比较特殊内部大多是native的方法，而且这个类也不允许我们随意使用，当然JDK自己是可以用的,(ps:处于凡是试试的态度，我试了一下调用它的方法，报错如下)
看一下valueOffset是哪来的
static {
try {
valueOffset = unsafe.objectFieldOffset
(AtomicInteger.class.getDeclaredField("value"));
} catch (Exception ex) { throw new Error(ex); }
}
这里又调用了Unsafe类的一个方法，参数是通过反射获取的AtomicInteger的value属性，也就是它的值
继续进
public native long objectFieldOffset(Field var1);
很可惜，是一个本地方法，查看文档可知，这个方法返回的就是"原来的值"的内存地址 ， valueOffset的值(ps:文档是其他某位大神那里借来的)
返回一开始的方法 点进去看
public final int getAndAddInt(Object var1, long var2, int var4) {
int var5;
do {
var5 = this.getIntVolatile(var1, var2);
} while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));
return var5;
}
参数比较混乱 var2就是valueOffset 继续跟进
public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);
喔，又是一个本地方法，参数很乱 按我们之前的讲就是：
var2(valueOffset) , var4(expectValue) , var5(newValue)
我再借一点注释
这个方法原子的将变量的值更新为var5，如果成功了返回true。这样返回去取反即为false，循环结束，返回var5，取到新值。
当然Unsafe关于CAS的方法都是本地方法，是由C语言实现的，我们这里是看不到具体实现细节的。
说了半天 到底CAS是怎么保证线程安全的呢，其实在语言层次我们是没有做任何关于同步的操作的，也没有任何锁。Atomic包下这些类将这些操作都交给了CPU和内存，利用CPU多处理的能力，实现硬件的阻塞，再加上volatile变量的特性即可实现基于原子性的操作的线程安全。所以CAS不是没有阻塞 ，只是阻塞不是语言层面，而是在硬件层面，这样便会更高效。