这一章应该是很枯燥，很晦涩的一章。总要面对的，不是吗？
先来简单的探探路~~
1、volatile的应用
在并发编程中我们经常会使用synchronize和volatile。volatile是轻量级的synchronize，成本较低。且不会引起线程上下文的切换和调度。
volatile的定义与实现原理
Java编程语言允许线程访问共享变量，为了确保共享变量能被准确的和一致的更新，线程应该确保通过排它锁单独获得这个变量。
知识延伸：
共享锁：如果事务T对数据A加上共享锁后，则其他事务只能对A再加共享锁，不能加排他锁。获准共享锁的事务只能读数据，不能修改数据。
排他锁：如果事务T对数据A加上排他锁后，则其他事务不能再对A加任任何类型的封锁。获准排他锁的事务既能读数据，又能修改数据。
那么volatile是如何保证可见性的呢？
说实话我也不知道是啥东西，但是看到后面有个lock ····应该就是了。我们不探究汇编语言，也不刨根到底，那样只会越陷越深。
lock前缀的作用是
1）将当前处理器缓存行的数据写回到系统内存
2）这个写回内存的操作会使其他CPU里缓存了改内存地址的数据无效
为什么要这样呢？因为如果不加lock前缀，平时为了提高处理速度，处理器和内存是不直接通信的，而是先将系统内存的数据读到内部缓存，然后再进行操作，但是操作不知道何年何月会写到内存中。如果是多核的话会有多个地方的CPU内部缓存，各自独立，当一个CPU改变了这个值之后，如果还有其他的CPU缓存是旧值，在进行操作的话就会有问题的。所以，我们声明了volatile后，在汇编里加了lock字段，然后CPU会使CPU缓存中的数据设为无效，然后会把这个数据写回系统内存。
2、synchronize的实现原理与应用
俗称重量级锁。但是SE1.6优化后，减肥了，没那么重了。
这一章节介绍Java SE1.6为了减少获得锁和释放锁带来的性能消耗，而引入的偏向锁和轻量锁，以及锁的存储结构和升级过程。
synchronize实现同步的基础：Java的每一个对象都可以作为锁。
- 对于普通同步方法，锁是当前实例对象
- 对于静态同步方法，锁的是当前类的Class对象
- 对于同步方法块，锁的是synchronize括号里配置的对象
当一个线程视图访问同步代码块的时候，它必须先得到锁，退出或者抛出异常时必须释放锁。
说了半天，到底什么是锁呢？锁里面存储着什么信息呢？
首先我们开看一下Java对象头，synchronize用的锁存在Java对象头里。
锁标记位在MarkWord中
当锁标志改变后的状态变化
我们大概了解是怎么一回事就可以了。不必深究，除非有必要。
重点来了
为了减少获得锁和释放锁带来的性能消耗，JavaSE1.6之后又引入了偏向锁和轻量级锁。
锁一共有四种状态，级别从低到高依次是：
无锁状态，偏向锁状态，轻量级锁状态，重量级锁状态
偏向锁：
大多数情况下，锁不仅不存在多线程竞争，而且总是由同一个线程多次获得，为了让线程获得锁的代价更低，而引入了偏向锁。当一个线程访问同步块并获得锁的时候，会在对象头和帧栈中的锁记录里存储偏向锁的线程id，参看上面的几张图。以后该线程进入和退出代码块的时候，不需要进行CAS操作来加锁和解锁。只需简单的验证一下对象头里的Mark Word是否有存储着当前线程的偏向锁。如果验证成功，那么表示线程已经获得了锁。如果失败，那么需要再测试一下Mark Word里偏向锁的标志是否设置成了1（表示当前是偏向锁）。如果没有设置那么就是CAS竞争锁，如果设置了，那么尝试使用CAS将对象头的偏向锁指向当前线程。
那么偏向锁是如何撤销的呢？
偏向锁采用了一种等到竞争出现才释放锁的机制，当有其他线程尝试竞争偏向锁的时候，持有偏向锁的线程才会释放锁。偏向锁的撤销需要等待全局安全点（就是这个时间点没有正在执行的字节码）。
他会先暂停拥有偏向锁的线程，然后检查持有偏向锁的线程是否活着，如果不处于活动状态，那么就好办了，将对象头设置成无锁状态。如果还活着，那么拥有偏向锁的栈会被执行，遍历偏向对象的锁记录，栈中的锁记录和对象头的Mark Word要么重新 偏向于其他线程，要么恢复到无锁或者标记对象不适合所谓偏向锁，最后唤醒暂停的线程。
如果你确定应用程序里所有的锁通常情况下都处于竞争状态，那么通过设置JVM关闭偏向锁。-XX：-UseBiasedLocking = false。那么程序默认会进入轻量级锁状态。
轻量级锁
1）轻量级锁加锁
线程在执行同步块的时候，JVM会现在当前线程的栈帧中创建用于存储锁记录的空间，并将对象头中的Mark Word复制到锁记录中，官方称为 Displaced Mark Word。然后线程尝试使用CAS将对象中的Mark Word替换为指向锁记录的指针。如果成功，当前线程获得锁，如果失败，表示其他线程竞争锁，当前线程尝试使用自旋来获取锁。
自旋锁（spin lock）是一种非阻塞锁，也就是说，如果某线程需要获取锁，但该锁已经被其他线程占用时，该线程不会被挂起，而是在不断的消耗CPU的时间，不停的试图获取锁。
自旋锁原理非常简单，如果持有锁的线程能在很短时间内释放锁资源，那么那些等待竞争锁的线程就不需要做内核态和用户态之间的切换进入阻塞挂起状态，它们只需要等一等（自旋），等持有锁的线程释放锁后即可立即获取锁，这样就避免用户线程和内核的切换的消耗。
2）轻量级锁解锁
轻量级解锁的时候，会使用原子的CAS操作将Display Mark Word 替换回到对象头，如果成功，那么表示没有竞争。如果失败，则表示当前锁有竞争，锁会膨胀成为重量锁。
因为自旋会消耗CPU，为了避免无用的自旋（比如获得锁的线程被阻塞了），一旦锁升级成重量级锁，那么就不会再恢复到轻量级锁状态了。当锁处于这个状态下，其他线程试图获取锁的时候，都会被阻塞住，当持有锁的线程释放锁之后才会唤醒这些线程，被唤醒的线程就会进行新一轮的夺锁之争了。
锁的优缺点
我们来理一理这几个锁的应用环境啊
首先偏向锁，适用于只有一个线程的同步块场景，没后竞争，一个人与世无争。
当有了竞争，但是执行速度都很快，任务都很轻量级别，那么就用轻量级锁，不会阻塞，只会自旋等一等，当然等的时间一定很短。不然超出自旋的最大时间就升级为阻塞，成为重量级锁了。按需选择，置定不同的策略，使用不同的锁。
最后我们来讲一下很重要的一个概念，原子操作。
原子操作的实现原理
原子（atomic）本意是不能被进一步分割的最小粒子。原子操作就是不可被中断的一个或者一系列操作。
先了解一下CPU术语CAS 很熟悉了吧。另外另个也顺便看看吧。
Java通过锁和循环CAS的方式来实现原子操作。
自旋CAS实现的基本思路就是循环进行CAS操作指导成功为止。
public class Run {
private AtomicInteger atomicInteger = new AtomicInteger(0);
private int i = 0;
public static void main(String[] args) {
final Run run = new Run();
List<Thread> ts = new ArrayList<>();
long start = System.currentTimeMillis();
for (int j = 0; j < 100; j++) {
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 10000; i++) {
run.count();
run.safeCount();
}
}
});
ts.add(thread);
}
for (Thread t : ts) {
t.start();
}
//等待所有线程执行完成
for (Thread t : ts) {
try {
t.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(run.i);
System.out.println(run.atomicInteger.get());
System.out.println(System.currentTimeMillis() - start);
}
private void safeCount() {
for (; ; ) {
int i = atomicInteger.get();
boolean suc = atomicInteger.compareAndSet(i, ++i);
if (suc) {
break;
}
}
}
private void count() {
i++;
}
}
最后的运行结果：
当然CAS实现原子问题不是完美的，它有三大问题。
1）ABA问题
当CAS需要在操作值得时候，检查值没有变化，但是原来值是A，后来B，最后又是A，那么使用CAS检查的时候，发现没有变化，但是其实是变化了，那么我们在变量前面加版本号，A->B->A,就变成了1A->2B->3A。Java1.5 提供了AtomicStampedReference类来解决了这一问题。
2）循环时间开销大
如果一直自旋CAS都不成功怎么办？会给CPU带来非常大的开销。
这就需要JVM支持pause指令，那么效率就提升上来了。
3）只能保证一个共享变量的原子操作
取巧的方法是 i= 2 ,j = a ,合并成 ij = 2a。
从Java1.5开始JDK提供了AtomicRefrence类来保证引用对象之间的原子性。可以把多个变量放到一个对象里进行CAS操作。
使用锁也能保证原子操作，锁机制保证了只有获得锁的线程才能操作锁定的内存区域。除了偏向锁，JVM实现锁的机制都用了循环CAS。当一个线程想进入同步块的时候使用循环CAS的方式来获取锁，当它退出同步块的时候使用循环CAS释放锁。
