01——Java并发机制的底层实现原理

1 Java并发机制的底层实现原理

1.1 volatile

1.1.1 volatile的作用

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

转换成汇编代码，如下：

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

Lock前缀的指令在多核处理器下保证三件事：

1. 将当前处理器缓存行的数据写回到系统内存
2. 这个写回内存的操作会使在其他CPU里缓存了该内存地址的数据无效
3. 重排序时不能把后面的指令重排序到内存屏障之前的位置，即禁止指令重排序

1.1.2 volatile不能保证原子性

private static volatile int counter = 0;

public static void main(String[] args) throws InterruptedException {
    for (int i = 0; i < 10; i++) {
        Thread thread = new Thread(() -> {
            for (int j = 0; j < 10000; j++) {
                add();
            }
        });
        thread.start();
    }
    Thread.sleep(1000);
    System.out.println(counter);
}

public static void add() {
    counter++;
}

代码运行预期结果应该是100000，但实际运行结果并非如此，counter的值会小于100000，这是因为volatile并不能保证原子性。

1.2 synchronized

1.2.1 synchronized具体表现形式

1. 对于普通同步方法：锁是当前实例对象
2. 对于静态同步方法：锁是当前类的Class对象
3. 对于同步方法快：锁是Synchronized括号里配置的对象

1.2.2 synchronized特性

1. 原子性

   private static volatile int counter = 0;
   
   public static void main(String[] args) throws InterruptedException {
       for (int i = 0; i < 10; i++) {
           Thread thread = new Thread(() -> {
               for (int j = 0; j < 10000; j++) {
                   add();
               }
           });
           thread.start();
       }
       Thread.sleep(1000);
       System.out.println(counter);
   }
   
   public static synchronized void add() {
       counter++;
   }
   

   add()方法加上synchronized关键字，保证了方法执行的原子性，从而保证运行结果一定为100000。

2. 可见性

   public static boolean sign = false;
   
   public static void main(String[] args) {
       Thread thread01 = new Thread(() -> {
           int i = 0;
           while (!sign) {
               i++;
               add(i);
           }
       });
   
       Thread thread02 = new Thread(() -> {
           try {
               Thread.sleep(3000);
           } catch (InterruptedException e) {
   
           }
           sign = true;
           logger.info("vt.sign = true,while(!sign)");
       });
   
       thread01.start();
       thread02.start();
   }
   
   public static int add(int i) {
       return i + 1;
   }
   

   这是两个线程操作一个变量的例子，因为线程间对变量 sign 的不可见性，线程 Thread01 中的 while (!sign) 会一直执行，不会随着线程 Thread02 修改 sign = true 而退出循环。

   而给add()方法加上synchronized关键字后，到当线程 Thread02 改变变量 sign = true 后，线程 Thread01 立即退出了循环。

   为什么synchronized也能保证变量的可见性呢？

   1、线程解锁前，必须把共享变量的最新值刷新到主存中。

   2、线程加锁前，将清空工作内存中共享变量的值，从而使用共享变量时需要从主存中重新读取最新的值。

   3、volatile的可见性靠内存屏障(Memory Barrier)来实现，而synchronized靠操作系统内核的互斥锁实现，相当于JMM中的lock，unlock。退出代码块时刷新变量到主内存。

3. 有序性

   as-if-serial，保证不管编译器和处理器为了性能优化会如何进行指令重排序，都需要保证单线程下的运行结果的正确性。也就是常说的：如果在本线程内观察，所有的操作都是有序的；如果在一个线程观察另一个线程，所有的操作都是无序的。

   //双重检查锁经典案例
   public class Singleton {
       private volatile static Singleton instance;
   
       private Singleton() {
       }
   
       public Singleton getInstance() {
           if (instance == null) {
               synchronized (Singleton.class) {
                   if (instance == null) {
                       instance = new Singleton();
                   }
               }
           }
           return instance;
       }
   }
   

   在DCL中，为什么synchronized也有可见性的特点，还需要volatile关键字？因为synchronized的有序性不是volatile的防止指令重排序。

   如果不加volatile关键字可能导致的结果是，第一个线程在初始化对象，设置instance指向内存地址时，第二个线程进入，有指令重排序，那么在判断if(instance == null)时就会有出错的可能，因为这时候可能instance还没有初始化成功。

4. 可重入性

   synchronized 是可重入锁，也就是说，允许一个线程二次请求自己持有对象锁的临界资源。

   synchronized锁对象的时候有个计数器，他会记录下线程获取锁的次数，在执行完对应的代码块之后，计数器就会-1，直到计数器清零，就释放锁了。

1.2.3 锁升级过程

synchronized 锁有四种交替升级的状态：无锁、偏向锁、轻量级锁和重量级，这几个状态随着竞争情况逐渐升级。锁可以升级但不能降级，意味着偏向锁升级成轻量级锁后不能降级成偏向锁。这种锁升级却不能降级的策略，目的是为了提高获得锁和释放锁的效率。

1. 偏向锁

   

   • 当一个线程访问同步块并获取锁时，会在对象头和栈帧中的锁记录里存储锁偏向的线程ID，以后该线程在进入和退出同步块时不需要进行CAS操作来加锁和解锁，只需简单地测试一下对象头的Mark Word里是否存储着指向当前线程的偏向锁。如果测试成功，表示线程已经获得了锁。如果测试失败，则需要再测试一下Mark Word中偏向锁的标识是否设置成1（表示当前是偏向锁）：如果没有设置，则使用CAS竞争锁；如果设置了，则尝试使用CAS将对象头的偏向锁指向当前线程。
   • 偏向锁使用了一种等到竞争出现才释放锁的机制，所以当其他线程尝试竞争偏向锁时，持有偏向锁的线程才会释放锁。偏向锁的撤销，需要等待全局安全点（在这个时间点上没有正在执行的字节码）。它会首先暂停拥有偏向锁的线程，然后检查持有偏向锁的线程是否活着，如果线程不处于活动状态，则将对象头设置成无锁状态；如果线程仍然活着，拥有偏向锁的栈会被执行，遍历偏向对象的锁记录，栈中的锁记录和对象头的Mark Word要么重新偏向于其他线程，要么恢复到无锁或者标记对象不适合作为偏向锁，最后唤醒暂停的线程。

2. 轻量级锁

   

   • 轻量级加锁：线程在执行同步块之前，JVM会先在当前线程的栈桢中创建用于存储锁记录的空间，并将对象头中的Mark Word复制到锁记录中，官方称为Displaced Mark Word。然后线程尝试使用CAS将对象头中的Mark Word替换为指向锁记录的指针。如果成功，当前线程获得锁，如果失败，表示其他线程竞争锁，当前线程便尝试使用自旋来获取锁。
   • 轻量级解锁：轻量级解锁时，会使用原子的CAS操作将Displaced Mark Word替换回到对象头，如果成功，则表示没有竞争发生。如果失败，表示当前锁存在竞争，锁就会膨胀成重量级锁。
   • 因为自旋会消耗CPU，为了避免无用的自旋（比如获得锁的线程被阻塞住了），一旦锁升级成重量级锁，就不会再恢复到轻量级锁状态。当锁处于这个状态下，其他线程试图获取锁时，都会被阻塞住，当持有锁的线程释放锁之后会唤醒这些线程，被唤醒的线程就会进行新一轮的夺锁之争。

1.3 原子操作的实现原理

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

1. 使用总线锁保证原子性

   如果多个处理器同时对共享变量进行读改写操作（i++就是经典的读改写操作），那么共享变量就会被多个处理器同时进行操作，这样读改写操作就不是原子的，操作完之后共享变量的值会和期望的不一致。举个例子，如果i=1，我们进行两次i++操作，我们期望的结果是3，但是有可能结果是2。

   

   原因可能是多个处理器同时从各自的缓存中读取变量i，分别进行加1操作，然后分别写入系统内存中。那么，想要保证读改写共享变量的操作是原子的，就必须保证CPU1读改写共享变量的时候，CPU2不能操作缓存了该共享变量内存地址的缓存。

   处理器使用总线锁就是来解决这个问题的。所谓总线锁就是使用处理器提供的一个LOCK＃信号，当一个处理器在总线上输出此信号时，其他处理器的请求将被阻塞住，那么该处理器可以独占共享内存。

2. 使用缓存锁保证原子性

   所谓“缓存锁定”是指内存区域如果被缓存在处理器的缓存行中，并且在Lock操作期间被锁定，那么当它执行锁操作回写到内存时，处理器不在总线上声言LOCK＃信号，而是修改内部的内存地址，并允许它的缓存一致性机制来保证操作的原子性，因为缓存一致性机制会阻止同时修改由两个以上处理器缓存的内存区域数据，当其他处理器回写已被锁定的缓存行的数据时，会使缓存行无效。

1.3.2 Java如何实现原子操作

1. 使用循环CAS实现原子操作

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

   CAS实现原子操作的问题

   (1) ABA问题：可利用版本号解决。

   ​ JDK的Atomic包里提供了一个类AtomicStampedReference来解决ABA问题。这个类的compareAndSet方法的作用是首先检查当前引用是否等于预期引用，并且检查当前标志是否等于预期标志，如果全部相等，则以原子方式将该引用和该标志的值设置为给定的更新值。

   (2) 循环时间长开销大。

   (3) 只能保证一个共享变量的原子操作。

   ​ 当对一个共享变量执行操作时，我们可以使用循环CAS的方式来保证原子操作，但是对多个共享变量操作时，循环CAS就无法保证操作的原子性，这个时候就可以用锁。还有一个取巧的办法，就是把多个共享变量合并成一个共享变量来操作。比如，有两个共享变量i＝2，j=a，合并一下ij=2a，然后用CAS来操作ij。从Java 1.5开始，JDK提供了AtomicReference类来保证引用对象之间的原子性，就可以把多个变量放在一个对象里来进行CAS操作。

2. 使用锁机制实现原子操作

   锁机制保证了只有获得锁的线程才能够操作锁定的内存区域。JVM内部实现了很多种锁机制，有偏向锁、轻量级锁和互斥锁。有意思的是除了偏向锁，JVM实现锁的方式都用了循环CAS，即当一个线程想进入同步块的时候使用循环CAS的方式来获取锁，当它退出同步块的时候使用循环CAS释放锁。

参考资料：

并发编程的艺术

Java面经手册—小傅哥