JUC并发编程第十二篇，详解Synchronized与锁升级

详解Synchronized与锁升级

- 一、概述
- 二、Synchronized 版本升级优化与锁对象
- - 1、版本变化
  - 2、为什么每一个对象都可以成为一个锁？
- 三、Synchronized锁升级步骤详解
- - 1、如何升级？
  - 2、无锁，不会出现竞争
  - 3、偏向锁
  - 4、轻量级锁
  - - 5、重锁
    - 6、三种锁的比较
- 四、补充：JIT编译器锁优化（即时编译器）

一、概述

我们都知道，用锁能够保证数据的安全性，但是会带来性能下降；无锁能够基于线程并行提升程序性能，但是会带来安全性问题，为了达到两着的平衡，于是就有了多种锁的实现和锁升级。
经过上一节的了解，我们知道了synchronized锁根据对象头中的 Mark Word 中的锁标志位的不同而区分，这一节来学习锁有哪几种类型以及是如何升级的。

二、Synchronized 版本升级优化与锁对象

1、版本变化

在java5以前，只有Synchronized，它是操作系统级别的重量级操作，假如锁的竞争比较激烈的话，会导致性能下降。

Java的线程是映射到操作系统原生线程之上的，如果要阻塞或唤醒一个线程就需要操作系统介入，需要在户态与核心态之间切换，这种切换会消耗大量的系统资源，因为用户态与内核态都有各自专用的内存空间，专用的寄存器等，用户态切换至内核态需要传递给许多变量、参数给内核，内核也需要保护好用户态在切换时的一些寄存器值、变量等，以便内核态调用结束后切换回用户态继续工作。

在Java早期版本中，synchronized属于重量级锁，效率低下，因为监视器锁（monitor）是依赖于底层的操作系统的Mutex Lock来实现的，挂起线程和恢复线程都需要转入内核态去完成，阻塞或唤醒一个Java线程需要操作系统切换CPU状态来完成，这种状态切换需要耗费处理器时间，如果同步代码块中内容过于简单，这种切换的时间可能比用户代码执行的时间还长，造成效率低下。
从Java6开始，优化Synchronized：为了减少获得锁和释放锁所带来的性能消耗，引入了轻量级锁和偏向锁，让锁有个逐步升级的过程，而不是一开始就使用最重的锁。

2、为什么每一个对象都可以成为一个锁？

因为Java中的对象都与JVM中的一个本地的C++对象对应，如下：
所以，Java对象是天生的Monitor，每一个Java对象天生就带了一把看不见的锁，它叫做内部锁或者Monitor锁。
Monitor的本质是依赖于底层操作系统的Mutex Lock实现，操作系统实现线程之间的切换需要从用户态到内核态的转换，成本非常高。
如果一个java对象被某个线程锁住，则该java对象的Mark Word字段中LockWord指向monitor的起始地址，Monitor的Owner字段会存放拥有相关联对象锁的线程id。

三、Synchronized锁升级步骤详解

1、如何升级？

synchronized用的锁存在于Java对象头里的Mark Word中，锁升级功能主要依赖Mark Word中锁标志位和释放偏向锁标志位。

2、无锁，不会出现竞争

代码演示：

public class MyObject{
    public static void main(String[] args){
        Object o = new Object();

        System.out.println("10进制hash码："+o.hashCode());
        System.out.println("16进制hash码："+Integer.toHexString(o.hashCode()));
        System.out.println("2进制hash码："+Integer.toBinaryString(o.hashCode()));

        System.out.println( ClassLayout.parseInstance(o).toPrintable());
    }
}

在这里插入图片描述

3、偏向锁

原理

当一段同步代码一直被同一个线程多次访问，由于只有一个线程那么该线程在后续访问时便会自动获得锁。（通过CAS方式修改markword中的线程ID）
经过观察，多线程情况下，锁总是被同一个线程持有，很少发生竞争，也就是说，锁总是被第一个占用他的线程拥有，这个线程就是锁的偏向线程。
在这种情况下，只需要在锁第一次被拥有的时候，记录下偏向线程ID，这样偏向线程就一直持有着锁，后续这个线程进入和退出这段加了同步锁的代码块时，不需要再次加锁和释放锁，而是直接比较对象头里面是否存储了指向当前线程的偏向锁。
如果相等表示偏向锁是偏向于当前线程的，就不需要再尝试获得锁了，直到竞争发生才释放锁。
以后每次同步，检查锁的偏向线程ID与当前线程ID是否一致，如果一致直接进入同步，无需每次加锁解锁都去CAS更新对象头。如果自始至终使用锁的线程只有一个，很明显偏向锁几乎没有额外开销，性能极高。
假如不一致则意味着发生了竞争，锁已经不是总是偏向于同一个线程了，这时候可能需要升级变为轻量级锁，才能保证线程间公平竞争锁。
偏向锁只有遇到其他线程尝试竞争偏向锁时，持有偏向锁的线程才会释放锁，线程是不会主动释放偏向锁的。

底层实现

一个synchronized方法被一个线程抢到了锁时，这个方法所在的对象就会在其所在的Mark Word中修改偏向锁的状态位，同时还会占用前54位来存储线程指针作为标识。
若该线程再次访问同一个synchronized方法时，该线程只需去对象头的Mark Word 中去判断一下是否有偏向锁指向本身的ID，无需再进入 Monitor 去竞争对象了。

代码演示

偏向锁在JDK1.6之后是默认开启的，但是启动时间有延迟，所以需要添加参数 -XX:BiasedLockingStartupDelay=0，让其在程序启动时立刻启动，不然就看不到效果。

public class MyObject {

    private static Object objectLock = new Object();

    public static void main(String[] args) {
        new Thread(() -> {
            synchronized (objectLock){
                System.out.println(ClassLayout.parseInstance(objectLock).toPrintable());
            }
        },"t1").start();
    }
}

在这里插入图片描述

偏向锁的撤销

当有另外线程逐步来竞争锁的时候，就不能再使用偏向锁了，持有偏向锁的原来线程会被撤销，升级为轻量级锁。
撤销需要等待全局安全点(该时间点上没有字节码正在执行)，同时检查持有偏向锁的线程是否还在执行：
如果第一个线程正在执行synchronized方法(处于同步块)，它还没有执行完，其它线程来抢夺，该偏向锁会被取消掉并出现锁升级。此时轻量级锁由原持有偏向锁的线程持有，继续执行其同步代码，而正在竞争的线程会进入自旋等待获得该轻量级锁。
如果第一个线程执行完成synchronized方法(退出同步块)，则将对象头设置成无锁状态并撤销偏向锁，重新偏向。

4、轻量级锁

轻量级锁是为了在线程近乎交替执行同步块时提高性能。它通过CAS，减少重量级锁使用操作系统互斥量产生的性能消耗，本质就是自旋锁。
假如线程A已经拿到锁，这时线程B又来抢该对象的锁，由于该对象的锁已经被线程A拿到，当前该锁已是偏向锁了。而线程B在争抢时发现对象头Mark Word中的线程ID不是线程B自己的线程ID(而是线程A)，那线程B就会进行CAS操作希望能获得锁。此时线程B操作中有两种情况：
- 如果锁获取成功，直接替换Mark Word中的线程ID为B自己的ID，相当于A线程被释放了锁，该锁开始偏向于B。
- 如果锁获取失败，则偏向锁升级为轻量级锁，此时轻量级锁由原持有偏向锁的线程持有，继续执行其同步代码，而正在竞争的线程B会进入自旋等待获得该轻量级锁。

代码演示：关闭偏向锁，关闭之后程序默认会直接进入轻量级锁状态。参数：-XX:-UseBiasedLocking
在这里插入图片描述

public class MyObject {

    private static Object objectLock = new Object();

    public static void main(String[] args) {
        new Thread(() -> {
            synchronized (objectLock){
                System.out.println(ClassLayout.parseInstance(objectLock).toPrintable());
            }
        },"t1").start();
    }
}

在这里插入图片描述

在java6之前，默认情况下自旋的次数是 10 次。
Java6之后，变成了自适应，自旋的次数不是固定不变的，而是根据同一个锁上一次自旋的时间和拥有锁线程的状态来决定。

5、重锁

有大量的线程参与锁的竞争，冲突性很高时使用，锁标志为 10

代码演示：

public class MyObject {

    private static Object objectLock = new Object();

    public static void main(String[] args) {
        new Thread(() -> {
            synchronized (objectLock){
                System.out.println(ClassLayout.parseInstance(objectLock).toPrintable());
            }
        },"t1").start();
        new Thread(() -> {
            synchronized (objectLock){
                System.out.println(ClassLayout.parseInstance(objectLock).toPrintable());
            }
        },"t2").start();
    }
}

在这里插入图片描述

6、三种锁的比较

synchronized锁升级过程：就是先自旋，不行再阻塞。
比较：
过程：

四、补充：JIT编译器锁优化（即时编译器）

锁消除：

/**
 * 锁消除
 * 从JIT角度看相当于无视它，synchronized (o)不存在了,这个锁对象并没有被共用扩散到其它线程使用
 * 也就是说，每个人加自己的锁，相当于没加锁，没用。
 */
public class LockClearUPDemo{
    static Object objectLock = new Object();//正常的
    public void m1(){
        //锁消除,JIT会无视它，synchronized(对象锁)不存在了。
        Object o = new Object();
        synchronized (o){
            System.out.println("-----hello LockClearUPDemo"+"\t"+o.hashCode()+"\t"+objectLock.hashCode());
        }
    }

    public static void main(String[] args){
        LockClearUPDemo demo = new LockClearUPDemo();
        for (int i = 1; i <=10; i++) {
            new Thread(() -> {
                demo.m1();
            },String.valueOf(i)).start();
        }
    }
}

锁粗化：

/**
 * 锁粗化
 * 假如方法中首尾相接，前后相邻的都是同一个锁对象，那JIT编译器就会把这几个synchronized块合并成一个大块，
 * 加粗加大范围，一次申请锁使用即可，避免次次的申请和释放锁，提升了性能
 */
public class LockBigDemo{
    static Object objectLock = new Object();

    public static void main(String[] args){
        new Thread(() -> {
            synchronized (objectLock) {
                System.out.println("11111");
            }
            synchronized (objectLock) {
                System.out.println("22222");
            }
            synchronized (objectLock) {
                System.out.println("33333");
            }
        },"a").start();

        new Thread(() -> {
            synchronized (objectLock) {
                System.out.println("44444");
            }
            synchronized (objectLock) {
                System.out.println("55555");
            }
            synchronized (objectLock) {
                System.out.println("66666");
            }
        },"b").start();
    }
}