并发02：java并发机制的底层实现原理

java代码在编译后会变成字节码，字节码再被类加载器加载到jvm中，jvm执行字节码，最终是需要将字节码转换成汇编指令放到cpu上执行，所以，java中的并发机制依赖于jvm的实现和cpu的指令

1. volatile的应用

多线程并发编程下volatile和synchronized都扮演着重要的角色，volatile是轻量级的synchronized，它在多线程中保证了共享变量的可见性。如果volatile使用的较为恰当的话，它比synchronized的使用和执行成本更低，因为它不会引起线程上下文切换和调度

1.1 volatile的定义和实现原理

1.1.1 定义

volatile定义如下：java编程语言允许线程访问共享变量，为了确保共享变量能被准确和一致性更新，线程应该确保通过排他锁单独获取这个变量，java语言提供了volatile，在某些情况下比锁更加方便，如果一个字段被声明成volatile，java线程内存模型确保所有线程看大这个变量的值是一致的

1.1.2 如何保证可见性

下面通过JIT编译器在X86环境下对一段java代码生成汇编指令来看看volatile在进行写操作是，CPU做了什么

instance = new Singleton(); // instance是volatile变量

0x01a3de1d: movb $0×0,0×1104800(%esi);0x01a3de24: lock addl $0×0,(%esp);

由上面的汇编代码可以看出，当变量被volatile修饰后，在进行写操作时，会在汇编代码中增加lock代码块，Lock前缀的指令在多核处理器上会引发两件事情

• 将当前处理器缓存行的数据写回到操作系统
• 写回内存的操作会使在其他CPU里缓存了该内存地址的数据无效

  为了提高处理速度，处理器不会直接和内存进行通信，而是先将系统内存的数据读取到内部缓存（L1、L2或其他）后再进行操作，但操作完后不知道何时会写回到内存，所以如果在对申明了volatile的变量进行写操作时，jvm就会向处理器发送一条Lock前缀的指令，将这个变量所在的缓存行的数据写回到系统内存，但是就算写回到内存，如果其他处理器缓存的值还是旧的，再执行计算操作，还是有问题。所以，在多处理器下，为了保证各个处理器的缓存是一致的，就会实现缓存一致性协议，每个处理器通过嗅探在总线上传播的数据来检查自己缓存的值是不是过期了，如果过期了，就会将当前处理器缓存行设置成无效状态，当处理器再次对这个数据进行修改操作时，会重启从系统内存中把数据读取到处理器缓存中

1.1.3 实现原则

• Lock前缀指令会引起处理器缓存回写到内存

  lock前缀指令执行，会申请处理器LOCK信号，在有此信号的情况下，处理器可以独占共享内存,但是这种处理方式是锁定总线，消耗很大，所以在最新的处理器内，已经不在锁定总线，而是锁定缓存行 如果访问的数据已经处于处理器的内部，不会申请处理器LOCK信号，而是去锁定当前内存区域的缓存并回写会内存，并使用缓存一致性机制来保证修改的原子性，此操作称之为缓存锁定，缓存一致性会阻止两个以上处理器同时修改共享内存区域数据

• 一个处理器缓存回写到内存会导致其他处理器的缓存失效

  IA-32处理器和Intel 64处理器使用MESI(修改、独占、共享、失效)控制协议去维护内部缓存和其他处理器缓存一致性。在多核处理器系统中进行操作的时候，IA-32和Intel 64处理器能嗅探到其他处理器访问系统内存和他们的内部缓存。处理器使用嗅探技术保证它的内部缓存、系统内存和其他处理器的缓存数据在总线上保持一致 通过嗅探返现其他处理器打算修改内存地址，该地址当前处于共享模式，那么当前处理器就会让他自己的对应的缓存行失效，在下次再次使用改内存地址是，强制执行缓存行填充

1.2 volatile的使用优化

LinkedTransferQueue是java并发包内的一个集合类，它在使用volatile变量时，用一种追加字节的方式来优化队列入队和出队的性能

/** 队列中的头部节点 */ 
private transient final PaddedAtomicReference<QNode> head; 
/** 队列中的尾部节点 */ 
private transient final PaddedAtomicReference<QNode> tail; 
static final class PaddedAtomicReference <T> extends AtomicReference T> { 
    // 使用很多4个字节的引用追加到64个字节 
    Object p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, pa, pb, pc, pd, pe; 
    PaddedAtomicReference(T r) { 
        super(r); 
    } 
}
public class AtomicReference <V> implements java.io.Serializable { 
    private volatile V value; 
    // 省略其他代码 
｝

可以看到PaddedAtomicReference类中定义了p0-pe 15个变量，共占用60个字节，再加上父类AtomicReference里面的value，正好是64个字节
为什么这种方式可以提高并发编程的效率？因为之前部分处理器的L1、L2或L3缓存的高速缓存行是64个字节宽度，不支持部分填充缓存行，如果队列的头结点和尾结点都不足64字节的话，处理器会将他们都读取到同一个高速缓存行，在多处理器下每个处理器都会缓存同样的头尾节点，当一个处理器试图修改头结点时，会将整个缓存行锁定，那么在缓存一致性机制的作用下，会导致其他处理器都不能访问自己的高速缓存中的尾节点，而队列入队和出队需要不停的修改头结点和尾节点，在此情况下，会严重影响队列的出入队效率。
那么在这种情况下，将每个节点强制填充到64字节，就可以防止节点都被存入同一个缓存行，防止了互相锁定的情况，从而提高了队列的出入队的效率。
但是以下两种情况不应该使用填充的方式

• 缓存行非64字节宽的处理器，有一些处理器的高速缓存行是32字节宽
• 共享变量不会被频繁的写

  变量不会被频繁写得情况下，就不需要太关注节点是否会相互锁定的情况，这样就不需要强制填满缓存行的64字节宽度，因为追加字节本身会带来一定的性能消耗

不过在java7下，这种方式填充可能会不生效，因为它会淘汰或重新排列无用的字段，所以需要使用其他的方式进行填充

2. synchronized

java中的每个对象度可以作为锁，具体怎么锁，有以下几种情况

• 对于普通同步方法，锁是当前实例对象
• 对于静态同步方法，锁是当前类的Class对象
• 对于同步方法块，锁是Synchronized括号里配置的对象

  2.1 实现原理

  synchronized是JVM的内置锁，JVM基于进入和退出Monitor对象来实现方法同步和代码块同步，单二者的实现细节不一样，代码块同步是使用monitorenter和monitorexit指令实现，而方法同步是使用另外一种方式实现，但是方法的同步可以使用这两个指令来实现

  monitorenter指令是在编译后插入到同步代码块的开始位置，而monitorexit是插入到方法结束处和异常处，JVM要保证monitorenter和monitorexit必须成对出现，任何对象都有一个monitor与之关联，当monitor被持有后，它将处于锁定状态。线程执行到monitorenter指令时，将会尝试获取对象锁对应的monitor的所有权，尝试获取对象的锁

2.2 java对象头

synchronized用的锁是存在java对象头里的，如果对象是数组类型，则虚拟机用3个字宽（Word）存储对象头，如果对象是非数组类型，则用2字宽存储对象头

在32位虚拟机中，1字宽 = 4字节，即32bit

java对象头里的Mark Word里默认存储对象的HashCode、分代年龄和锁标记位。32位的Mark Word的默认存储结构如下

在运行期，Mark Word里存储的数据会随着锁标志位的变化而变化。Mark Word可能变化为存储以下4种数据

64位虚拟机下，Mark Word是64bit大小的，其存储结构如下

2.3 锁的升级与对比

为了减少获得锁和释放锁带来的性能的消耗，引入了偏向锁和轻量级锁，这几个状态会根据竞争情况逐渐升级
注意：锁升级是个单项操作，可以升，不可以降，这种策略的目的也是为了提高获取锁和释放锁的效率
锁的四种级别

• 无锁状态
• 偏向锁状态
• 轻量级锁状态

• 重量级锁状态

  2.3.1 偏向锁

  大多数情况下锁不仅不存在多线程竞争，反而总是由一个线程多次获取，为了让线程获取锁的代价更低，引入了偏向锁。

  2.3.1.1 偏向锁的初始化

  当一个线程党文同步块并获取锁时，会在对象头和栈帧中的锁记录里存储锁偏向的线程ID，以后该线程在进入和退出同步块是不需要进行CAS操作就可以加锁和释放锁，只需要简单的验证下对象头中的Mark Word里是否存储这指向当前线程的偏向锁，如果测试成功，表示线程已经获得了锁，如果测试失败，则需要测试下Mark Word中偏向锁的标识是否设置成了1（1表示当前锁为偏向锁），如果没有设置，则使用CAS竞争锁，如果设置了，则尝试使用CAS将对象头的偏向锁指向当前线程

  2.3.1.2 偏向锁的撤销

  偏向锁使用了一种等到竞争出现才会释放锁的机制，所以当其他线程尝试竞争偏向锁时，持有偏向锁的线程才会释放锁。
  偏向锁的撤销流程

• 等待全局安全点（在这个时间点上没有正在执行的字节码）

• 暂停拥有偏向锁的线程
• 检查持有偏向锁的线程是否还活着
  • 如果线程不处于活动状态，将对象头设置成无锁状态
  • 如果线程处于活动状态，拥有偏向锁的栈会被执行
• 便利偏向对象的锁记录，栈中的锁记录和对象头的Mark Word要么重新偏向于其他线程，要么恢复到无锁状态或者标记对象不适合作为偏向锁，最后唤醒暂停的线程

  2.3.1.3 关闭偏向锁

  偏向锁在java6之后是默认开启的，但是它在应用程序启动几秒钟之后才激活，如有必要可以使用JVM参数关闭延迟

  -XX:BiasedLockingStartupDelay=0

  如果你确定应用程序里所有的锁通常情况下都处于竞争状态，则可以通过JVM参数关闭偏向锁

  -XX:-UseBiasedLocking=false

  一旦关闭了偏向锁，程序默认会进入轻量级锁状态

  2.3.2 轻量级锁

  2.3.2.1 加锁

  线程在执行同步块之前，JVM会先在当前线程的栈帧中创建用于存储锁记录的空间，并将对象头中的Mark Word复制到锁记录中，官方称为Displaced Mark Word。然后线程尝试使用CAS将对象头中的Mark Word替换为指向锁记录的指针，如果成功，当前线程获得锁，如果失败，表示其他线程竞争锁，当前线程便尝试使用自旋来获取锁

  2.3.2.2 解锁

  解锁时会使用CAS操作将Displaced Mark Word替换回对象头，如果成功，则表示没有锁竞争发生，如果失败，表示有锁竞争，锁就会膨胀成重量级锁

  因为自旋会消耗CPU，为了避免无用的自旋，一旦锁升级成重量级锁，就不会在退化到轻量级锁，当锁处于这个状态下，其他线程试图获取锁时，都会被阻塞住，当持有锁的线程释放锁之后会唤醒这些阻塞的线程，被唤醒的线程就会进行新一轮的锁竞争

2.4 锁的优缺点

3. 原子操作

原子操作意思就是不可被中断的一个或者一系列操作

3.1 处理器如何实现原子操作

1. 使用总线锁

如果多个处理器同时对共享变量进行读写操作，那么共享变量就会被多个处理器同时进行操作，这样读写操作就不是原子的，操作完之后共享变量的值会和预期不一致。
处理器使用总线锁解决这个问题，所谓总线锁就是使用处理器提供的一个LOCK#信号，当一个处理器在总线上输出信号时，其他处理器的请求将被阻塞，那么该处理器就可以独占共享内存了
总线锁会将CPU和内存之前的通信锁住，使得锁定期间，其他处理器不能操作其他内存的数据，所以总线锁定的开销比较大

1. 使用缓存锁

由于总线锁开销较大，所以目前处理器在某些场合使用缓存锁代替总线锁来进行优化
缓存锁会使用缓存一致性机制保证操作的原子性，因为缓存一致性会阻止两个以上处理器修改内存区域数据，当其他处理器回写已被锁定的缓存行数据时，会使自身的缓存行失效，这里使用了嗅探技术。
但有两种情况下处理器不会使用缓存锁定
第一种情况：当操作的数据不能被缓存在处理器内部，或者操作的数据跨多个缓存行时，处理器会使用总线锁定
第二种情况：有些处理器不支持缓存锁定，就算锁定的内存区域在处理器的缓存行中，也会调用总线锁定

3.2 java如何实现原子操作

java中可以通过锁和循环CAS的方式来实现原子操作

3.2.1 使用CAS

JVM中的CAS操作正是利用了处理器提供的CMPXCHEG指令实现的，自旋CAS实现的基本思路就是循环进行CAS操作直到成功为止。

3.2.1.1 CAS实现原子操作三大问题

1. ABA问题

如果一个值从A变成B又变成A，此时用CAS检查会发现它的值没发生变化，但是实际上却变化了。
解决思路是加版本号
JDK的atomic包中提供了一个类AtomicStampedReference来解决ABA问题

public boolean compareAndSet( 
    V expectedReference, // 预期引用
    V newReference,      // 更新后的引用
    int expectedStamp,   // 预期标志
    int newStamp         // 更新后的标志
)

1. 循环时间长，开销大
2. 只能保证一个共享变量的原子操作

   3.2.2 使用锁