多线程-锁升级测试+ 源码

小灰灰 2023-01-04 14:35 148阅读 0赞

多线程加锁是为了当多个线程同时调用相同代码块时，将多线程在该代码块上的并行变成串行，一个一个执行，这样就能保证每个线程能拿到“最新的”变量，从而避免各线程计算出错。

`sychronized` 是常用的加锁手段， 在JDK 1.6 之前，`synchronized(obj)` 会直接在操作系统中为 obj 专门创建一个 monitor 对象。A 线程执行 `synchronized(obj){...}` 时，会将 A 的线程 ID 写到 monitor 的 owner 属性中。此时 如果B 线程也要执行该代码段，会先去检查 monitor.woner，发现里面是 A，那么B 线程就会等待（陷入阻塞），B线程将它的线程 ID 写到 monitor 的等待队列(EntryList) 中“沉睡”， 待 A 线程执行完后，操作系统“唤醒”B线程，B 将自己的线程ID 写到 monitor.woner 中，并开始执行该代码块。

# 重量级锁由来 #

线程 A、B 运行在 JVM 之上，JVM 运行在操作系统之上。 monitor 是在操作系统内部创建的对象， 它本质上依赖于操作系统的 互斥锁(Mutex Lock) 实现的。操作系统在执行线程切换时，需要在用户空间和内核空间执行切换，中间会涉及到大量的系统变量保存与读取，这是个很 “重” 的操作，所以就有了【重量级锁】这个称号。

操作系统执行线程切换会耗费较大的时间，并发量大时，重量级锁的执行效率很低，而当只有单线程时，就为 obj 创建 monitor 对象又显得很不划算。因为单线程不涉及并发，直接执行就好了。

# 重量级锁优化 #

所以，1.6 以后就对重量级锁进行了优化。优化的思路是：依旧采用 `synchronized(obj){...}` 的代码形式执行加锁，但 JVM 在执行时，别一上来就加重量级锁，关联到操作系统底层。而是在 JVM 层面先解决下，等到场景实在不行了，再创建重量级锁。

基于这个思路，在具体的实现上就出现了【偏向锁】和【轻量级锁】。从而根据不同的线程场景，出现了 `偏向锁 --> 轻量级锁 --> 重量级锁` 这样的一个锁升级过程。

# 对象的锁状态 #

了解各种锁状态之前，先看得看下java对象的组成，因为对象锁的状态肯定写在该对象的某个地方。一个 java 对象由三部分构成：对象头，实例数据，对齐填充。平时代码中写的成员变量就属于实例数据部分，对象的锁状态信息存储在对象头里面。

这里以 32 虚拟机与 64 为虚拟机对象头的内容是一样的，区别只是存放内容的位数不一样。32平米的房子里能住一个人，那这个人住在64平米的房子里也是没问题的。这里以 32 位虚拟机为例。

对象头由两部分构成：

*  Mark Word 存放跟锁相关的信息。
 *  Klass Word 存放着该对象属于哪个类。

|-----------------------------------------------------------|
    |                    Object Header (64 bits)                |
    |---------------------------------|-------------------------|
    |             Mark Word (32 bits) | Klass Word (32 bits)    |
    |---------------------------------|-------------------------|

详细看下 Mark Word 的状态：

|-------------------------------------------------------------------|
    |                      Mark Word(32bits)               |   State    | 
    |-------------------------------------------------------------------|    
    |     hashcode:25         | age:4 | biased_lock:0 | 01 |   无状态    |   
    |-------------------------------------------------------------------|    
    |     thread:23 | epoch:2 | age:4 | biased_lock:1 | 01 |   偏向锁    |    
    |-------------------------------------------------------------------|    
    |     ptr_to_lock_record:30                       | 00 |   轻量级    |     
    |-------------------------------------------------------------------|    
    |    ptr_to_heavyweight_monitor:30                | 10 |   重量级    | 
    |-------------------------------------------------------------------|    
    |                                                 | 11 |   垃圾回收  | 
    |-----------------------------------------------------------------

**无状态和偏向锁**：Mark Word 的倒数第三位 `biased_lock` 表示该对象是否开启偏向锁，只有开启对象锁的对象才能线程加上对象锁。JVM 默认延迟 4s 左右开启对象锁，就是说 程序刚运行时，前 4s 内创建的对象是无状态的(001)，4s 以后创建的对象都是开启偏向锁的，这些对象 Mark Word 后三位都是 101。

**轻量级锁**：Mark Word 的最后两位是 00，前面的空间用来存放锁记录的地址。JVM会给每个线程分配一定的栈空间，线程执行方法时，会在栈空间中创建一个栈帧，锁记录是栈帧里面的一个对象。

**重量级锁**：Mark Word 的最后两位是 10，前面的空间用来存放 monitor 的地址（指针）。 前面提到过，monitor 是操作系统内部的对一个对象。

从这里可以看出，偏向锁和轻量级锁都是在 JVM 层面加的锁，说白了都是 java对象交换了地址，这些都能在 JVM 层面处理掉。只有重量级锁涉及要与操作系统内部的对象执行地址交换。

# 锁升级过程 #

1.6 以后，开发者依旧只需要使用 synchronized 对代码块执行加锁，至于该加哪种锁，由 JVM 自己根据线程调用情况进行判断，并适当执行锁升级过程。从而实现对 synchronized 的优化。

## 无状态和开启偏向 ##

JVM 默认延时开启偏向，时间大概 4s 左右。但可以通过参数设定，关闭默认延迟开启偏向锁。

public static void test0() throws InterruptedException { 
        User user1 = new User();
        System.out.println("无状态(001):" + ClassLayout.parseInstance(user1).toPrintable());
    
        // 默认 4s 以后开启偏向锁
        Thread.sleep(5000);
        User user2 = new User();
        System.out.println("开启偏向(101):" + ClassLayout.parseInstance(user2).toPrintable());
    }

user1：  
![image-20210110141316536][]  
User2：  
![20210110141543.png][]

## 偏向锁 ##

当对象开启偏向锁后， 如果只是单线程调用（很常见的场景），或者 多线程调用但是没有竞争，`synchronized(obj)` 会给 obj 加偏向锁。

public static void test1() throws InterruptedException { 
        Thread.sleep(5000);
        User user2 = new User();
    	
        // for 循环模拟机同一线程重复加锁。
        for (int i = 0; i < 2; i++) { 
          synchronized (user2) { 
            System.out.println("加偏向锁(101),并带着线程id：" + ClassLayout.parseInstance(user2).toPrintable());
          }
          System.out.println("释放偏向锁(101),并带着线程id：" + ClassLayout.parseInstance(user2).toPrintable());
        }
      }

加偏向锁：  
![20210110142723.png][]  
释放偏向锁：  
![20210110142804.png][]

可以观察到，当 `synchronized(user){}` 代码块执行完后，user2 的 Mark Word 字段没有变化。偏向锁不会主动释放，目的是当同一线程再次对该代码段加锁时，user2 的 Mark Word 存放着自己的线程 ID，那就直接执行代码块，不用再执行加锁过程（省去了交换线程 ID 的步骤）。

**偏向锁的目的：单线程执行同步资源(synchronized代码块)时，可以直接获取资源，不需要重复执行加锁过程**。（注意一点，此时没有线程竞争）

这里可能有迷惑，单线程没有并发不需要加锁呀，搞这个干嘛。问题是开发者写的时候觉得这块大概率会出现并发，所以用了 synchronized，但他预估不到此时是单线程执行呀。等到JVM 执行的时候，发现当前是单线程执行，JVM 就寻思着“单线程执行，给你创建个偏向锁就可以了，没必要搞 monitor 。多线程出现竞争了，我再升级下锁就可以了”。这样就 避免了一上来就创建重量级锁。

## 轻量级锁 ##

即便是代码块执行结束，偏向锁加上后也不会被释放，当另一个线程执行synchronized (obj) 时，会直接将 obj 从偏向锁升级到轻量级锁。

public static void test2() throws InterruptedException { 
    	Thread.sleep(5000);
        User user2 = new User();
        // 主线程给 user2 加偏向锁
        synchronized (user2) { 
          System.out.println("加偏向锁(101),并带着线程id：" + ClassLayout.parseInstance(user2).toPrintable());
        }
        Thread.sleep(100);
        // 新线程给 user2 加轻量级锁
        new Thread(() -> { 
          synchronized (user2) { 
            System.out.println("轻量级锁(00),带着线程id:" + ClassLayout.parseInstance(user2).toPrintable());
          }
          System.out.println("轻量级锁释放，变成无状态(001)" + ClassLayout.parseInstance(user2).toPrintable());
        }).start();
    	// 第三次加锁
        Thread.sleep(500);
        synchronized (user2) { 
          System.out.println("再次加锁" + ClassLayout.parseInstance(user2).toPrintable());
        }
        System.out.println("再次释放锁" + ClassLayout.parseInstance(user2).toPrintable());
    }

偏向锁：  
![20210110145931.png][]

轻量级锁：  
![20210110145735.png][]

轻量级锁释放：  
![20210110150321.png][]

再次加锁：  
![20210110151349.png][]

再次释放锁：  
![20210110151500.png][]  
从测试结果可以看出：

1.  其他线程给偏向锁对象再加锁时，JVM 会将偏向锁升级成轻量级锁，当线程执行完代码块后，对象的轻量级锁会被释放，变成无锁状态。
2.  一个对象只能被加一次偏向锁，如果锁被升级后，以后每次加锁至少是轻量级的。（其实就是对象锁只能升级，不能降级）。
3.  注意一下，这里出现了多线程，但没有并发。

那轻量级锁的目的是什么呢？

这里得先简单说下 `synchronized(obj)` 执行轻量级加锁时干了什么事情。栈帧里有个所记录对象：lockRecord。A 线程给 obj 加锁时，先将 `lockRecord 的地址 + 00` 写到 obj 的Mark word 里面， 再将 obj 的地址写到 lockRecord 中保存，做了一次交换，等释放轻量锁时，再将 obj 恢复成无状态的。

**轻量锁的目的：当多个线程竞争同步资源时，没有获取到资源的线程会自旋等待锁释放。比如：A 线程正在执行 `synchronized(obj)` 还没结束，B 线程也要执行该代码块，B 发现 obj 不是无状态的，B就开始等着，隔一会就检查下 obj 没有被释放，没释放就继续等，再隔一会，再检查。这个“等待–> 检查 --> 等待–>检查”的过程就叫自旋。如果 B 自旋了很少几次，A就释放锁了，那B开始给 obj 加轻量级锁，并开始执行代码块。**

对线程加锁时，JVM 会自动加轻量级锁，当出现竞争时，没获得锁的线程会先采用自旋的方式“盯着”锁被释放。线程自旋占用了 CPU 的计算，而且是空转，当自旋次数较小时，采用 cpu 的计算时间换操作系统切换线程的开销，还是很划算的。

## 重量级锁 ##

自旋是有次数限制， 默认允许 10 次，但可以通过虚拟机参数更改。在 java 6 之后自旋锁是自适应的，比如对象刚刚的一次自旋操作成功过，那么认为这次自旋成功的可能性会高，就多自旋几次；反之，就少自旋甚至不自旋，总之，比较智能。

但如果长时间自旋依旧依旧等不到锁释放时，此时，JVM 就会将轻量级锁升级到重量级锁。

private static void test3() throws InterruptedException { 
        Thread.sleep(5000);
        User user2 = new User();
        System.out.println("开启偏向(101):" + ClassLayout.parseInstance(user2).toPrintable());
    
        synchronized (user2) { 
          System.out.println("加偏向锁(101),并带着线程id：" + ClassLayout.parseInstance(user2).toPrintable());
        }
    
        new Thread(() -> { 
          synchronized (user2) { 
            System.out.println("轻量级锁(00),带着线程id:" + ClassLayout.parseInstance(user2).toPrintable());
            try { 
                // 占着锁不释放
              Thread.sleep(3000);
            } catch (InterruptedException e) { 
              e.printStackTrace();
            }
          }
        }).start();
    
        Thread.sleep(1000);
        new Thread(() -> { 
          synchronized (user2) { 
            System.out.println(" 重量级锁(10),带着线程id:" + ClassLayout.parseInstance(user2).toPrintable());
          }
        }).start();
        
        Thread.sleep(3000);
        System.out.println(" 重量级锁释放:" + ClassLayout.parseInstance(user2).toPrintable());
      }

加重量级锁：  
![20210110162421.png][]  
重量级锁释放：  
![20210110162543.png][]  
从测试结果可以看到，重量级锁释放后，对象也会被恢复成无状态的。

之前提到过，重量级锁会关联到操作系统中的 monitor 对象。

**重量级锁的目的是：多个线程竞争同步资源时，没有获取到资源的线程会陷入阻塞，陷入“沉睡”，被动等待被唤醒。“盯着”了好久都没拿到锁，而且还很费 CPU 开销，那不如放弃 CPU 空转，自己进入等待队列，让别人（操作系统）来唤醒自己。**

## 小结一下： ##

1.  开发者依旧使用 `synchronized(obj) {}` 形式加锁，至于加哪种锁，JVM 会根据当前线程自己确定。
2.  只有单线程加锁时，JVM 会加偏向锁，这样当单线程重复加锁时，可以直接执行代码块。
3.  一个对象只能被加一次偏向锁，因为单线程不会重复加锁，多线程会加轻量级锁，锁只能升级不能降级。
4.  多线程加锁时，JVM 会加轻量级锁，当出现多线程竞争同步资源时，未获得资源的线程会先自旋，等待轻量级锁释放。（“盯着”）。
5.  当自旋超过限制时，JVM 会将轻量级锁升级到重量级锁，操作系统给 obj 创建 monitor 对象，没有拿到锁的线程进入 monitor 的等待队列中，等待被唤醒。（“沉睡”）
6.  轻量级锁和重量级锁释锁后，obj 会变成无状态。
7.  偏向锁本身就是串行，轻量级锁在JVM 层面将多线程并行变成串行，重量级锁将多线程并行变成串行要借助操作系统创建对象，并执行线程调度。

# 两个小问题： #

1.  给未开启偏向的对象加锁，会加成什么锁？
    
    会直接加成轻量级锁。
2.  线程加了偏向锁，且还没有执行完毕，此时出现多线程竞争，锁会怎么变？
    
    我测试的结果是：没获得锁的线程线程接升级到重量级锁，并陷入阻塞，等待锁释放。

[image-20210110141316536]: https://raw.githubusercontent.com/diego1109/pictures/main/20210110141316.png
[20210110141543.png]: https://raw.githubusercontent.com/diego1109/pictures/main/20210110141543.png
[20210110142723.png]: https://raw.githubusercontent.com/diego1109/pictures/main/20210110142723.png
[20210110142804.png]: https://raw.githubusercontent.com/diego1109/pictures/main/20210110142804.png
[20210110145931.png]: https://raw.githubusercontent.com/diego1109/pictures/main/20210110145931.png
[20210110145735.png]: https://raw.githubusercontent.com/diego1109/pictures/main/20210110145735.png
[20210110150321.png]: https://raw.githubusercontent.com/diego1109/pictures/main/20210110150321.png
[20210110151349.png]: https://raw.githubusercontent.com/diego1109/pictures/main/20210110151349.png
[20210110151500.png]: https://raw.githubusercontent.com/diego1109/pictures/main/20210110151500.png
[20210110162421.png]: https://raw.githubusercontent.com/diego1109/pictures/main/20210110162421.png
[20210110162543.png]: https://raw.githubusercontent.com/diego1109/pictures/main/20210110162543.png