Java锁机制--锁概述 锁升级

Java锁原理

在探究Java锁原理之前我们需要知道一些基础知识，方便对锁的理解：

• synchronized关键字
• CAS
• Java对象内存模型

CAS

CAS概述

CAS（Compare And Swap）比较和替换

定义一个int类型的变量a，初始值为0。

• 线程A先获取变量a的值为0，然后执行加一操作，然后线程A会比较一下这个变量a是否还是0，如果是0，我们把它修改为1.
• 如果不是0，说明被其他线程动过，我们获取这个新的变量值a，执行加一操作，然后再去比较一下这个变量a又被其他线程动过，如果被动过，重复此操作，直至变量a在我们执行加一操作前后没有被动过。

Java对象模型

这个对象模型的详细内容我单独放在这篇博文。

一个Java对象可以分为三部分存储在内存中，分别是:

• 对象头 (Header)
• 实例数据 (Instance Data)
• 对齐填充 (Padding)

1. markword

​ markword 固定长度8byte，描述对象的identityhashcode，分代年龄，锁信息等

2. classpoint

   classpoint固定长度4byte, 指定该对象的class类对象。

3. 实例数据：

​ 基本变量：用于存放java八种基本类型成员变量，以4byte步长进行补齐，使用内存重排序优化空间

​ 引用变量：存放对象地址，如String，Object；

4. padding 补齐：

​ 对象大小必须是8byte的整数倍，用来补齐字节数。

5. 数组长度：

​ 数组长度：如果是数组，额外占用固定4byte存放数组长度；

对象头信息(markword)

锁升级

锁的状态

• 无锁

• 偏向锁

• 轻量级锁

• 重量级锁

我们的锁信息是存放在对象头的markword里面的。

无锁

无锁是指没有对资源进行锁定，所有的线程都能访问并修改同一个资源，但同时只有一个线程能修改成功。

无锁的特点是修改操作会在循环内进行，线程会不断的尝试修改共享资源。如果没有冲突就修改成功并退出，否则就会继续循环尝试。如果有多个线程修改同一个值，必定会有一个线程能修改成功，而其他修改失败的线程会不断重试直到修改成功。

偏向锁

偏向锁是指当一段同步代码一直被同一个线程所访问时，即不存在多个线程的竞争时，那么该线程在后续访问时便会自动获得锁，从而降低获取锁带来的消耗，即提高性能。

初次执行到synchronized代码块的时候，锁对象变成偏向锁（通过CAS修改对象头里的锁标志位），字面意思是“偏向于第一个获得它的线程”的锁。执行完同步代码块后，线程并不会主动释放偏向锁。当第二次到达同步代码块时，线程会判断此时持有锁的线程是否就是自己（持有锁的线程ID也在对象头里），如果是则正常往下执行。由于之前没有释放锁，这里也就不需要重新加锁。如果自始至终使用锁的线程只有一个，很明显偏向锁几乎没有额外开销，性能极高。

轻量级锁

轻量级锁是指当锁是偏向锁的时候，却被另外的线程所访问，此时偏向锁就会升级为轻量级锁，其他线程会通过自旋（关于自旋的介绍见文末）的形式尝试获取锁，线程不会阻塞，从而提高性能。

在轻量级锁状态下继续锁竞争，没有抢到锁的线程将自旋，即不停地循环判断锁是否能够被成功获取。获取锁的操作，其实就是通过CAS修改对象头里的锁标志位。先比较当前锁标志位是否为“释放”，如果是则将其设置为“锁定”，比较并设置是原子性发生的。这就算抢到锁了，然后线程将当前锁的持有者信息修改为自己。

重量级锁

重量级锁是指当有一个线程获取锁之后，其余所有等待获取该锁的线程都会处于阻塞状态。

简言之，就是所有的控制权都交给了操作系统，由操作系统来负责线程间的调度和线程的状态变更。而这样会出现频繁地对线程运行状态的切换，线程的挂起和唤醒，从而消耗大量的系统资源。

锁升级过程

• 无锁到偏向锁

  初次执行到synchronized代码块的时候，锁对象变成偏向锁，通过CAS修改对象头里的锁标志位。

• 偏向锁到轻量级锁

  轻量级锁是指当锁是偏向锁的时候，却被另外的线程所访问，此时偏向锁就会升级为轻量级锁

• 轻量级锁到重量级锁

  如果锁竞争情况严重，某个达到最大自旋次数的线程，会将轻量级锁升级为重量级锁，依然是CAS修改锁标志位，但不修改持有锁的线程ID。

锁升级的目的

锁竞争

这里要明确一下什么是锁竞争：如果多个线程轮流获取一个锁，但是每次获取锁的时候都很顺利，没有发生阻塞，那么就不存在锁竞争。只有当某线程尝试获取锁的时候，发现该锁已经被占用，只能等待其释放，这才发生了锁竞争。

我们Java团队发现，很多情况下，即便是多线程环境，由于每次占用资源的时间短，实际上可能没有发生锁竞争，偏向锁主要就是对这个层面进行优化。

自旋

轻量级锁是通过自选的方式来等待资源的，在Jdk1.6我们的自旋尝试次数是一个JVM参数，默认是10。但是在后序版本中，自旋的尝试次数都交给JVM进行控制，也就是编程了自适应自旋锁。

简单的说就是锁变聪明了，假如上一次CAS尝试了十次并且成功了。我们此次CAS自旋了十次也没有成功，但是由于上一次CAS成功了，我们自适应自旋锁认为本次也很可能成功，会多尝试几次。

忙等

长时间的自旋操作是非常消耗资源的，一个线程持有锁，其他线程就只能在原地空耗CPU，执行不了任何有效的任务，这种现象叫做忙等（busy-waiting）。如果多个线程用一个锁，但是没有发生锁竞争，或者发生了很轻微的锁竞争，那么synchronized就用轻量级锁，允许短时间的忙等现象。这是一种折衷的想法，短时间的忙等，换取线程在用户态和内核态之间切换的开销。

用户态和内核态

线程挂起

重量级锁是指当有一个线程获取锁之后，其余所有等待获取该锁的线程都会处于阻塞状态。

简言之，就是所有的控制权都交给了操作系统，由操作系统来负责线程间的调度和线程的状态变更。而这样会出现频繁地对线程运行状态的切换，线程的挂起和唤醒，从而消耗大量的系统资源。

演示锁升级过程

JOL工具

java对象布局JOL(java object layout),描述对象在堆内存的布局

<dependency>
    <groupId>org.openjdk.jol</groupId>
    <artifactId>jol-core</artifactId>
    <version>0.9</version>
</dependency>

基本使用

@Test
public void unlocked(){
    System.out.println(ClassLayout.parseInstance(object).toPrintable());
}

结果
默认是无锁状态

偏向锁

我们Java虚拟机对于4秒之内就执行完毕的程序是不会开启偏向锁的，所以我们这里让线程睡五秒来开启偏向锁

@Test
public void biasedLocking() throws Exception{
	Thread.sleep(5000); //等待jvm开启偏向锁
	System.out.println(ClassLayout.parseInstance(object).toPrintable());
    synchronized (object){
        System.out.println(ClassLayout.parseInstance(object).toPrintable());
    }
}

结果

轻量级锁

让两个线程出现竞争

public static void main(String[] args) throws InterruptedException {
    Thread.sleep(5000);
    Object o = new Object();
    synchronized (o) {
      System.out.println(ClassLayout.parseInstance(o).toPrintable());
    }
    for (int i = 0; i < 1; i++) {
      Thread t = new Thread(() -> {
        print(o);
      });
      t.start();
    }
  }
 
  public static void print(Object o) {
    synchronized (o){
      System.out.println(ClassLayout.parseInstance(o).toPrintable());
    }
  }

结果

重量级锁

让线程等待时间变长一点

public static void main(String[] args){
    Object o = new Object();
    for (int i = 0; i < 2; i++) {
      Thread t = new Thread(() -> {
        print(o);
      });
      t.start();
    }
  }
 
  public static void print(Object o) {
    synchronized (o){
      System.out.println(ClassLayout.parseInstance(o).toPrintable());
    }
  }

结果