尚硅谷（121-139）

Synchronized 锁升级

入门简介

一些面试题：

谈谈你对 Synchronized 的理解

synchronized 的锁升级

在阿里的规范里： 高并发时，同步调用应该去考量锁的性能损耗。能用无锁数据结构，就不要用锁；能所区块，就不要所整个方法体；能用对象锁，就不要用类锁。这里有一个原则： 尽可能使加锁的代码工作量尽可能小，避免在所代码中调用RPC方法。

synchronized 可以实现数据的安全，但是会带来性能的下降。

锁升级的过程：无锁、偏向锁、轻量级锁（cas等），重量级锁（synchronized）

锁的性能变化背景

Java 5以前，只有synchronized，这个是操作系统级别的重量级锁，会切换用户态和内核态。这一步是十分消耗资源，因为用户态和内核态都有各自的内存空间，专用寄存器等，用户态切换至内核态需要传递许多变量、参数给内核态，同时，内核态转为用户态同样需要转移这些数据。除此以外，因为监视器锁（monitor）是依赖于底层的操作系统 Mutex Lock（系统互斥量）

monitor 可以理解为一种同步工具或者机制，常被描述为一个Java对象。Java 对象是天生的 monitor ，每一个Java对象都有成为monitor 的潜质，因为他内部天然带了一把看不见的锁，叫做内部锁或者monitor 锁

public class MyObject{
    public static void main(String[] args){
        Object objectLock = new Object();
        new Thread(()->{
            sychronized(objectLock){
                ....
            }
        },"t1").start();
    }
}

monitor 的本质是依赖于底层操作系统的 Mutex Lock 实现，操作系统实现线程之间的切换需要从用户态到内核态的转换，成本很高，monitor锁是由cpp的ObjectMonitor.hpp文件实现。

Java 6 之后，为了减少获得锁和释放锁所带来的性能消耗，引入例如轻量级锁和偏向锁，需要一个锁升级的过程

锁升级的流程

对于访问情况有三种情况：

只有一个线程访问，有且唯一Only One
有多个线程（2个线程A、B来交替访问）
竞争激烈，更多个线程来访问

锁升级的流程

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

在这里插入图片描述

偏向锁：Mark Word存储的是偏向的线程ID

轻量锁：Mark Word存储的是指向线程栈中 Lock Record 的指针

重量锁：Mark Word存储的是指向堆中的monitor对象的指针

无锁

Mark Word末三位001，偏向锁位0，锁标志位01

这里说明一下，一个类在new出来的时候，hashCode是0，只有在调用hashCode方法的时候才会给hashCode赋值

偏向锁

偏向锁：单线程竞争

当线程A第一次竞争到锁时，通过操作修改Mark Word中的偏向线程ID、偏向模式。如果不存在其他线程竞争，那么持有偏向锁的线程将永远不需要进行同步。

就是：当一段同步代码一直被同一个线程多次访问，由于只有一个线程那么该线程在后续访问时变会自动获得锁。

偏向锁汇偏向于第一个访问锁的线程，如果在接下来的运行过程中，该锁没有被其他线程访问，则只有偏向锁的线程将永远不需要出发同步。也就是偏向锁在资源没有竞争情况下消除了同步语句，连cas都不用做了，直接提高性能。

实例代码

class Tickets{
    private static int tickets = 50;
    Object o = new Object();
    public void sale() {
            synchronized (o){
                if (tickets>0) {
                tickets--;
                System.out.println(Thread.currentThread().getName()+"抢到了票，剩余"+tickets+"张票！");
            }
        }
    }
}
public class SaleTickets {
    public static void main(String[] args) {
        Tickets tickets = new Tickets();
        new Thread(()->{
            for (int i = 0; i < 55; i++) {
                tickets.sale();
            }
        },"t3").start();
        new Thread(()->{
            for (int i = 0; i < 55; i++) {

                tickets.sale();
            }

        },"t1").start();
        new Thread(()->{
            for (int i = 0; i < 55; i++) {
                tickets.sale();
            }
        },"t2").start();

    }
}
/**
t3抢到了票，剩余49张票！
t1抢到了票，剩余48张票！
t1抢到了票，剩余47张票！
t1抢到了票，剩余46张票！
t1抢到了票，剩余45张票！
t3抢到了票，剩余44张票！
t3抢到了票，剩余43张票！
t3抢到了票，剩余42张票！
t3抢到了票，剩余41张票！
t3抢到了票，剩余40张票！
t3抢到了票，剩余39张票！
t3抢到了票，剩余38张票！
t3抢到了票，剩余37张票！
t3抢到了票，剩余36张票！
t3抢到了票，剩余35张票！
t3抢到了票，剩余34张票！
t3抢到了票，剩余33张票！
t3抢到了票，剩余32张票！
t3抢到了票，剩余31张票！
t3抢到了票，剩余30张票！
t3抢到了票，剩余29张票！
t3抢到了票，剩余28张票！
t3抢到了票，剩余27张票！
t3抢到了票，剩余26张票！
t3抢到了票，剩余25张票！
t3抢到了票，剩余24张票！
t3抢到了票，剩余23张票！
t3抢到了票，剩余22张票！
t3抢到了票，剩余21张票！
t3抢到了票，剩余20张票！
t3抢到了票，剩余19张票！
t3抢到了票，剩余18张票！
t3抢到了票，剩余17张票！
t3抢到了票，剩余16张票！
t3抢到了票，剩余15张票！
t3抢到了票，剩余14张票！
t3抢到了票，剩余13张票！
t3抢到了票，剩余12张票！
t3抢到了票，剩余11张票！
t3抢到了票，剩余10张票！
t3抢到了票，剩余9张票！
t3抢到了票，剩余8张票！
t3抢到了票，剩余7张票！
t3抢到了票，剩余6张票！
t3抢到了票，剩余5张票！
t3抢到了票，剩余4张票！
t3抢到了票，剩余3张票！
t3抢到了票，剩余2张票！
t3抢到了票，剩余1张票！
t3抢到了票，剩余0张票！
*/

从上述代码可以得知，基本都是被t3线程获取锁。注意是同一个对象调用方法，方法中有同步块。

理论落地：

在实际应用运行过程中发现，“锁总是同一个线程持有，很少发生竞争”，也就是说锁总是被第一个占用他的线程拥有，这个线程就是锁的偏向线程。

那么只需要在锁第一次被拥有的时候，记录下偏向线程ID。这样偏向线程就一直持有着锁(后续这个线程进入和退出这段加了同步锁的代码块时，不需要再次加锁和释放锁。而是直接会去检查锁的MarkWord里面是不是放的自己的线程ID)。

如果相等，表示偏向锁是偏向于当前线程的，就不需要再尝试获得锁了，直到竞争发生才释放锁。以后每次同步，检查锁的偏向线程ID与当前线程ID是否一致，如果一致直接进入同步。无需每次加锁解锁都去CAS更新对象头。如果自始至终使用锁的线程只有一个，很明显偏向锁几乎没有额外开销，性能极高。

如果不等，表示发生了竞争，锁已经不是总是偏向于同一个线程了，这个时候会尝试使用CAS来替换MarkWord里面的线程ID为新线程的ID，

竞争成功，表示之前的线程不存在了，MarkWord里面的线程ID为新线程的ID，锁不会升级，仍然为偏向锁;

竞争失败，这时候可能需要升级变为轻量级锁，才能保证线程间公平竞争锁。

注意，偏向锁只有遇到其他线程尝试竞争偏向锁时，持有偏向锁的线程才会释放锁，线程是不会主动释放偏向锁的。

技术实现：

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

细节讲解：

偏向锁的操作不用直接捅到操作系统，不涉及用户到内核转换，不必要直接升级为最高级。

假如有一个线程执行到synchronized代码块的时候，JVM使用CAS操作把线程指针ID记录到Mark Word当中，并修改标偏向标示，标示当前线程就获得该锁。锁对象变成偏向锁（通过CAS修改对象头里的锁标志位）﹐字面意思是“偏向于第一个获得它的线程”的锁。执行完同步代码块后，线程并不会主动释放偏向锁。

这时线程获得了锁，可以执行同步代码块。当该线程第二次到达同步代码块时会判断此时持有锁的线程是否还是自己（持有锁的线程ID也在对象头里)，JMM通过account对象的Mark Word判断:当前线程ID还在，说明还持有着这个对象的锁，就可以继续进入临界区工作。由于之前没有释放锁，这里也就不需要重新加锁。如果自始至终使用锁的线程只有一个，很明显偏向锁几乎没有额外开销，性能极高。结论:JVM不用和操作系统协商设置Mutex(争取内核)，它只需要记录下线程ID就标示自己获得了当前锁，不用操作系统接入。

上述就是偏向锁：在没有其他线程竞争的时候，一直偏向偏心当前线程，当前线程可以一直执行。

参数启动偏向锁

/**
*实际上偏向锁在JDK1.6之后是默认开启的，但是启动时间有延迟
*所以需要添加参数-XX:BiasedLockingStartupDeLay=0，让其在程序启动时立刻启动。
*开启编向锁:
*-XX :+UseBiasedLocking -XX:BiasedLockingStartupDelay=0
*关闭稿向锁:关闭之后程序默认会直接进入----
*----------------------->>>>>>>>轻量级锁状态。
* -XX:-UseBiasedLocking
*/

偏向锁的撤销

偏向锁使用一种等到竞争出现才释放锁的机制，只有当其他线程竞争锁时，持有偏向锁的原来线程才会被撤销。

撤销需要等待全局安全点(该时间点上没有字节码正在执行)，同时检查持有偏向锁的线程是否还在执行:

第一个线程正在执行synchronized方法 (处于同步块)，它还没有执行完，其它线程来抢夺，该偏向锁会被取消掉并出现锁升级。此时轻量级锁由原持有偏向锁的线程持有，继续执行其同步代码，而正在竞争的线程会进入自旋等待获得该轻量级锁。
第一个线程执行完成synchronized方法 (退出同步块) ，则将对象头设置成无锁状态并撤销偏向锁，重新偏向。

在这里插入图片描述

Java 15 偏向锁被废弃。

锁升级

在这里插入图片描述

轻量级锁

多线程竞争，但是在任意时刻，最多只有一个线程竞争，即不存在锁竞争太过激烈的情况，也就没有线程阻塞。

主要作用

有线程参与竞争，但是又获取时间极短，本质就是自旋锁cas

轻量级锁的获取

轻量级锁是为了在线程近乎交替执行同步块时提高性能。

主要目的：在没有多线程竞争的前提下，通过CAS减少重量级锁使用操作系统互斥量产生的性能消耗，说白了先自旋，不行才升级阻塞。

升级时机：当关闭偏向锁功能或多线程竞争偏向锁会导致偏向锁升级为轻量级

假如线程A已经拿到锁，这时线程B又来抢该对象的锁，由于该对象的锁已经被线程A拿到，当前该锁已是偏向锁了。

而线程B在争抢时发现对象头Mark Word中的线程ID不是线程B自己的线程ID(而是线程A)，那线程B就会进行CAS操作希望能获得锁。此时线程B操作中有两种情况:

如果锁获取成功，直接替换Mark Word中的线程ID为B自己的ID(A转为B)，重新偏向于其他线程(即将偏向锁交给其他线程，相当于当前线程"被"释放了锁)，该锁会保持偏向锁状态，A线程Over，B线程上位;
如果锁获取失败，则偏向锁升级为轻量级锁(设置偏向锁标识为O并设置锁标志位为OO)，此时轻量级锁由原持有偏向锁的线程持有，继续执行其同步代码，而正在竞争的线程B会进入自旋等待获得该轻量级锁。

轻量级锁的加锁

JVM会为每个线程在当前线程的栈帧中创建用于存储锁记录的空间，官方成为Displaced Mark Word。若一个线程获得锁时发现是轻量级锁，会把锁的MarkWord复制到自己的Displaced Mark Word里面。然后线程尝试用CAS将锁的MarkWord替换为指向锁记录的指针。如果成功，当前线程获得锁，如果失败，表示Mark Word已经被替换成了其他线程的锁记录，说明在与其它线程竞争锁，当前线程就尝试使用自旋来获取锁。

自旋CAS:不断尝试去获取锁，能不升级就不往上捅，尽量不要阻塞

轻量级锁的释放

在释放锁时，当前线程会使用CAS操作将Displaced Mark Word的内容复制回锁的Mark Word里面。如果没有发生竞争，那么这个复制的操作会成功。如果有其他线程因为自旋多次导致轻量级锁升级成了重量级锁，那么CAS操作会失败，此时会释放锁并唤醒被阻塞的线程。

代码演示

关闭偏向锁，直接进入轻量级锁 -XX:-UseBiasedLocking

可以使用前面偏向锁代码

锁流程

Java 6 之前，默认自旋次数是10次，可以使用 -XX:PreBlockSpin=10 来修改。

或者自旋线程为内核数量的一半。

Java 6 之后采用自适应自旋锁。

自适应自旋锁的大致原理

线程如果自旋成功了，那下次自旋的最大次数会增加。因为JVM认为既然上次成功了，那么这一次也很大概率会成功。
反之，如果很少会自旋成功，那么下次会减少自旋的次数甚至不自旋，避免CPU空转。

总结来说，自适应意味着自旋的次数不是固定的，而是根据同一个锁上一次自旋的时间以及拥有的线程的状态决定。

轻量级锁和偏向锁的区别

争取轻量级锁失败时，自旋尝试抢占锁
轻量级锁退出同步块之后会释放锁，偏向锁是在竞争发生时才释放锁。

重锁

参与场景：有大量锁参与竞争了

重量级锁原理

Java中synchronized的重量级锁，是基于进入和退出 Monitor 对象实现的。在编译时会将同步块的开始位置插入monitor enter指令，在结束位置插入monitor exit指令。

当线程执行到monitor enter指令时，会尝试获取对象所对应的Monitor所有权，如果获取到了，即获取到了锁，会在Montor的owner中存放当前线程的id，这样它将处于锁定状态，除非退出同步块，否则共他线程石法获取到这个Monitor。

锁升级与HashCode的关系

锁升级为轻量级或重量级锁后，Mark Word中保存的分别是线程栈帧里的锁记录指针和重量级锁指针，已经没有位置再保存哈希码，GC年龄了，那么这些信息被移动到哪里去了呢?

在无锁状态下，Mark Word中可以存储对象的identity hash code值。当对象的hashCode()方法第一次被调用时，JVM会生成对应的identity hash code值并将该值存储到Mark Word中。
对于偏向锁，在线程获取偏向锁时，会用Thread ID和epoch值覆盖identity hash code所在的位置。如果一个对象的hashCode()方法已经被调用过一次之后，这个对象不能被设置偏向锁。因为如果可以的化，那Mark Word中的identity hash code必然会被偏向线程ld给覆盖，这就会造成同一个对象前后两次调用hashCode()方法得到的结果不一致。
升级为轻量级锁时，JVM会在当前线程的栈帧中创建一个锁记录(Lock Record)空间，用于存储锁对象的Mark Word拷贝，该拷贝中可以包含identity hashcode，所以轻量级锁可以和identity hash code共存，哈希码和GC年龄自然保存在此，释放锁后会将这些信息写回到对象头。
升级为重量级锁后，Mark Word保存的重量级锁指针，代表重量级锁的ObjectMonitor类里有字段记录非加锁状态下的IMark Word，锁释放后也会将信息写回到对象头。

当一个对象已经计算过 identity hashcode ，他就无法进入偏向锁而是直接进入轻量级锁

TimeUtil.SECONDS.sleep(5);	
Object o = new Object();
o.hashcode();
synchronized(o){ // 本应是偏向锁，由于计算过hash偏向锁升级为轻量级锁
   
}

当偏向锁过程中遇到一致性hash请求，起码撤销偏向模式，膨胀为重量级锁

TimeUtil.SECONDS.sleep(5);	// 充分开启偏向锁
Object o = new Object();
synchronized(o){
    o.hashcode();// 在偏向锁的过程中，没有重写，一致性hashcode，撤销偏向锁，直接膨胀为重量解锁
}

JIT对锁的优化

JIT（Just In Time Compiler，即时编译器）

锁消除：

// 消除锁问题，JIT会无视它，每次new出来的o不存在了
Object o = new Object();
synchronized(o){	// 此时，锁没有任何意义
    
}

锁粗化： 假如方法中首尾相接，前后相邻的都是同一个锁对象，那JIT编译器就会把那几个synchronized块合并成一个大块，加粗加大范围，一次申请锁使用即可，避免此次的申请锁和释放锁，提升性能

Object o = new Object();
synchronized(o){	
    // 1
}
synchronized(o){	
    // 2
}
synchronized(o){	
    // 3
}
synchronized(o){	
    // 4
    
}
/**
synchronized(o){		// 底层合并为了一个大块
	// 1
	// 2
	// 3
    // 4
}
*/

总结

在这里插入图片描述

synchronized锁升级过程总结:一句话，就是先自旋，不行再阻塞。

实际上是把之前的悲观锁(重量级锁)变成在一定条件下使用偏向锁以及使用轻量级(自旋锁CAS)的形式

synchronized在修饰方法和代码块在字节码上实现方式有很大差异，但是内部实现还是基于对象头的MarkWord来实现的。

JDK1.6之前synchronized使用的是重量级锁，JDK1.6之后进行了优化，拥有了无锁->偏向锁→轻量级锁→>重量级琐的升级过程，而不是无论什么情况都使用重量级锁。

偏向锁：适用于单线程适用的情况，在不存在锁竞争的时候进入同步方法l代码块则使用偏向锁。
轻量级锁：适用于竞争较不激烈的情况(这和乐观锁的使用范围类似)，存在竞争时升级为轻量级锁，轻量级锁采用的是自旋锁，如果同步方法/代码块执行时间很短的话，采用轻量级锁虽然会占用cpu资源但是相对比使用重量级锁还是更高效。
重量级锁：适用于竞争激烈的情况，如果同步方法/代码块执行时间很长，那么使用轻量级锁自旋带来的性能消耗就比使用重量级锁更严重，这时候就需要升级为重量级锁。