CAS无锁技术
CAS算法即是：Compare And Swap,比较并且替换；
CAS算法存在着三个参数，内存值V，旧的预期值A，以及要更新的值B。当且仅当内存值V和预期值B相等的时候，才会将内存值修改为B，否则什么也不做，直接返回false;
比如说某一个线程要修改某个字段的值，当这个值初始化的时候会在内存中完成，根据Java内存模型，该线程保存着这个变量的一个副本；当且仅当这个变量的副本和内存的值如果相同，那么就可以完成对值得修改，并且这个CAS操作完全是原子性的操作，也就是说此时这个操作不可能被中断。
先来看一个n++的问题：
public class Case {
public volatile int n;
public void add() {
n++;
}
}
上述代码中什么变量被volatile修饰，此时说明该变量在多线程操作的情况下可以保证内存的可见性，但是不可以保证原子性操作，因此在多线程并发的时候还是会出现问题的；利用Javap命令来看看汇编指令：
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
|
在方法add()中，第17行表示获取到了n的初始值；
第19行执行了iadd()操作，n加一；
第20行执行了putfield,把新累加的值赋值给n；
在上面我很清楚的说过volatile确实无法保证上述三个操作步骤的原子性；可以使用synchrnoized的方法完成原子性的操作；synchrnoized是互斥锁，也是可重入的锁，可以保证操作的原子性；但是加锁之后效率降低，
好了，接下来再看一段代码：
public int a = 1;
public boolean compareAndSwapInt(int b) {
if (a == 1) {
a = b;
return true;
}
return false;
}
上述方法在并发的情况下也是会出现问题的；当多个线程直接进入compareAndSwapInt()之后，他们也同时符合上述的逻辑判断，此时对a的赋值也有可能同事发生，这样也带来了线程安全的问题； 同样加锁的方式也可以解决这个问题，但是在这里我们不研究锁的问题；下面我们来看看一段代码，这是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;
/**
* Gets the current value.
*
* @return the current value
*/
public final int get() {
return value;
}
}
1 Unasfe是CAS的核心类，通过这个类可以获取字段在内存中的地址偏移量；Unsafe是native的，我们一般不可能使用；这是Java对硬件操作的支持；
2 valueOffset是地址偏移量（变量在内存中的地址偏移量）
3 value是使用volatile修饰的，保证了内存的可见性；
平时做常用的方法addAndGet()方法；作用是原子性的操作给变量添加值；
int |
addAndGet(int delta) 以原子方式将给定值与当前值相加。 |
在Java8中，这个方法的实现是调用了unsafe()方法；因此我们看不到；
public final int addAndGet(int delta) {
return unsafe.getAndAddInt(this, valueOffset, delta) + delta;
}
但是通过网上看到了该方法的实现方式：
public final int addAndGet(int delta) {
for (;;) {
int current = get();
int next = current + delta;
if (compareAndSet(current, next))
return next;
}
}
public final int get() {
return value;
}
假设delta的值为1，在CAS算法下操作的话，首先进入一个for循环体；假设存在着两个线程，并且内存中的值value=3;根据Java内存模型，每一个线程都存在这这个变量的副本；
1) 线程1进入循环体，获取到current的值为3，然后获取到到next的值此时为4；此时假设线程1运气不好，被挂起；
2）线程2进入循环体，获取到current的值为3，同时next的值也为4；线程2运气好，此时继续执行compareAndSet（）方法；
public final boolean compareAndSet(int expect, int update) {
return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
}
线程2传入两个参数，一个当前值，以及一个预期值；当前值，也就是current=3.要修改成为4；此时当前值也就是预期值和内存中的value比较，此时都是3，那么修改内存中的值为4；
3）线程1此时再次执行compareAndSwapInt()方法的时候。发现内存中的值为4，预期的值是3，两者不相等，此时就不可以再次赋值了；
CAS的缺点：
CAS存在和“ABA的漏洞”；什么是ABA呢？
假定在某个时刻某个线程从内存中取出A，然后在下个时刻准备更新这个值；在这个时间差内数据发生了改变；
假设线程1从内存中取出了A，线程2也从内存中取出了A，并且将值修改为B，最后又改为A，当线程1去更新值得时候发现内存中的数据和线程备份数据相同，可以更新；但是此时内存中的值其实发生了变化的，只不过又变回去了；在实际的开发过程中，ABA可能会带来一些问题，但是我认为无关紧要，我们需要的只是数值的变化而已；
对于单向链表实现的栈而言；假设存在一个链表 A---->B;线程1要去将栈顶的数据修改为B，但是此时线程2进来之后，A---->B出栈，D、C、A压栈；此时链表的结构发生了变化；A---->C---->D；此时线程1发现栈顶元素还是A，而元素B被出栈之后成为一个游离的对象，
解决方式：由于CAS算法没有直接的使用锁；而是通过乐观锁的方式去控制并发的；而对于乐观锁而言一般都是操作+时间戳来控制每一次的版本号的；在JDK类库中，可以使用AutomicStampReference来解决