多线程JUC 第2季 synchronized锁升级过程

一 synchronized的概述

1.1 synchronized的特性

用锁能够实现数据的安全，但是会带来性能下降。Synchronized是一个重量级锁，锁的升级过程：无锁->偏向锁->轻量级锁->重量级锁。

高并发时，同步调用应尽量考虑锁的性能损耗，能用无锁数据结构，就不要用锁，能用区块不要用锁住整个方法体；能有对象锁，就不要用类锁。

1.2  synchronized锁性能低效原因

在java中早期版本中，synchronized属于重量级锁，效率低下，因为监视器monitor是依赖于底层操作系统的Mutex Lock（系统互斥量）来实现的。挂起和唤醒线程，需要做用户态和内核之间的切换，时间成本相对较高。java6后，为了减少获得锁和释放锁所带来的性能消耗，引入轻量级锁和偏向锁。

1.3 monitor作用

monitor是一种同步工具，是一种同步机制，可以描述为一个java对象，java对象是天生的monitor，每一个java对象都有成为monitor的潜质，因为在java的设计中，每一个java对象自打娘胎里就带了一把看不见的锁，他叫做内部的monitor锁。

 1.4 ObjectMonitor的作用

jvm中的同步就是基于进入和退出管程对象实现的，每个对象实例都会有一个monitor，monitor可以和对象一起创建、销毁。其中moniior时由objectmonitor实现的，而objectmonitor是由c++的objectmonitor.hpp文件实现的。

 1.5 synchronized的升级流程

synchronized使用锁，存储在java对象头部里的mark down字段里，锁升级主要依赖于markdown中的锁标志位和释放偏向锁标志位

1.偏向锁：markdown存储的是偏向的线程id；

2.轻量锁：markdown存储的是指向线程栈中Lock Record的指针。

3.重量锁：markdown存储的是指向堆中的monitor对象的指针

一个synchronized方法被一个线程抢到了锁时，那么这个方法所在的对象就会在其所在的mark word中将偏向锁修改状态位，同时还会占用前54位来存储线程指针作为标识。如果该线程再次访问同一个synchronized方法时，该线程只要去对象头的mark word中去判断也给是否有偏向锁指向本身id，不需要再进入monitor去竞争该对象了。

1.6 总结比较篇

 1偏向锁：适用于单线程的情况，在不存在锁竞争的时候进入同步方法/代码块则使用偏向锁
2.轻量级锁：适用于竞争比较不激烈的情况,存在竞争时升级为轻量级锁，轻量级锁采用的时自旋锁，如果同步方法/代码块执行时间很短的话，采用轻量级锁虽然很占用cpu资源，但是相对于使用重量级锁还是更高效的。
3.重量级锁：使用于竞争激烈的情况，如果同步方法/代码块执行时间很长，那么使用轻量级锁自旋带来的性能消耗就比使用重量级锁更严重，
这个时候就需要升级为重量级锁。
synchronized锁升级过程：先自旋，不行再阻塞。

1.7 monitor与java对象的关系

monitor与java对象的关系
1.如果一个java对象被某个线程锁住，该java对象的markword字段中的lockword指向monitor的起始地址
2.monitor的owner字段会存储拥有关联对象锁的线程id
3.mutex lock(互斥量)的切换需要从用户态切换到内核态，因此状态转换需要耗费很多处理器的时间

1.8 锁升级流程

1）当只有一个线程去争抢锁的时候,会先使用偏向锁,就是给一个标识,说明现在这个锁被线程a占有.
2）后来又来了线程b,线程c,说凭什么你占有锁,需要公平的竞争,于是将标识去掉,也就是撤销偏向锁,升级为轻量级锁,三个线程通过CAS自旋进行锁的争抢(其实这个抢锁过程还是偏向于原来的持有偏向锁的线程).
3）现在线程a占有了锁,线程b,线程c一直在循环尝试获取锁,后来又来了十个线程,一直在自旋,那这样等着也是干耗费CPU资源,所以就将锁升级为重量级锁,向内核申请资源,直接将等待的线程进行阻塞.

二  无锁状态

2.1 介绍

无锁状态，一个对象被实例化后，如果还没有被任何线程竞争锁，那么它为无锁状态(001)

1.结构： 前两行为8字节；后一行为类型指针4字节。

 2.读取流程3.结论：无锁状态，一个对象被实例化后，如果还没有被任何线程竞争锁，那么它为无锁状态(001)

三  偏向锁

3.1 偏向锁概念

当一段同步代码一直被同一个线程多次访问，由于只有一个线程，那么该线程再后续访问时便会自动获得锁。它是为了解决只有在一个线程执行同步时提高性能。

3.2 代码案例模拟

1.ticket

package com.ljf.haha;

/**
 * @ClassName: Ticket
 * @Description: TODO
 * @Author: admin
 * @Date: 2023/09/17 07:14:52 
 * @Version: V1.0
 **/
public class Ticket {
    private int num=50;
    Object lockObj=new Object();
    public void sale(){
        synchronized (lockObj){
            if(num>0){
                System.out.println(""+Thread.currentThread().getName()+"卖出:"+num--+"票，还剩:"+num);
            }
        }
    }
}

2.测试

package com.ljf.haha;

/**
 * @ClassName: Test
 * @Description: TODO
 * @Author: admin
 * @Date: 2023/09/17 07:15:00 
 * @Version: V1.0
 **/
public class Test {
    public static void main(String[] args) {
        Ticket ticket=new Ticket();
        new Thread(new Runnable() {
            @Override
            public void run() {
             for(int k=0;k<55;k++){
                 ticket.sale();
             }
            }
        },"A").start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                for(int k=0;k<50;k++){
                    ticket.sale();
                }
            }
        },"B").start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                for(int k=0;k<50;k++){
                    ticket.sale();
                }
            }
        },"C").start();



System.out.println("----");
    }
}

2.结果

3.3 偏向锁上锁过程

锁总是被第一个占用他的线程拥有，这个线程就是锁的偏向线程。
锁在被第一次拥有的时候，记录下偏向线程id，这样偏向线程就一直持有着锁(后续这个线程进入和退出这段加了同步锁的代码块时，不需要再次加锁和释放锁)，而是直接会去检查锁的markword里面是不是放的自己的线程id。
1.如果相等，表示偏向锁是偏向于当前线程的，就不需要在尝试获得锁了，直到竞争发生了才释放锁。以后每次同步，检查锁的偏向线程id与当前线程id是否一致，如果一致直接进入同步。无需每次加锁解锁都去cas更新对象头。如果自始至终使用锁的线程只有一个，很明显偏向锁几乎没有额外开销，性能极高。
2.如果不等，表示发生了竞争，锁已经不是总是偏向于同一个线程了，这个时候合尝试使用cas来替换markword里面的线程id为新线程id。
2.1 竞争成功，表示之前的线程不存在了，markword里面的线程id为新线程id，锁不会升级，仍然为偏向锁。
2.2 竞争失败，这个时候可能需要升级为轻量级锁，才能保证线程间公平竞争锁。
注意：偏向锁只有遇到其它线程尝试竞争偏向锁时，持有偏向锁的线程才会释放锁，线程是不会主动释放偏向锁的。

一个synchronized方法被一个线程抢到了锁时，那么这个方法所在的对象就会在其所在的mark word中将偏向锁修改状态位，同时还会占用前54位来存储线程指针作为标识。如果该线程再次访问同一个synchronized方法时，该线程只要去对象头的mark word中去判断也给是否有偏向锁指向本身id，不需要再进入monitor去竞争该对象了。

3.4 偏向锁上锁过程案例说明

假如有一个线程执行到synchronized代码块的时候，jvm使用cas操作把线程指针id记录到mark word当中，并修改偏向标志，表示当前线程获得该锁。锁对象变成偏向锁(通过cas修改对象头里的锁标志位)。从字面意思可以理解为“偏向于第一个获得它的线程”的锁，执行完同步代码块后，线程并不会主动释放偏向锁这时线程获得了锁，可以执行同步代码块。

当该线程第二次执行同步代码块时，会判断此时持有锁的线程是否还是自己(持有锁的线程id也在对象头里)，jvm通过account对象markword判断当前线程id还在，说明还持有者这个对象的锁，就可以继续进行临界区的工作。由于之前没有释放锁，这里也就不需要重新加锁。

特点： 自始至终使用的线程只有一个，很明显偏向锁几乎没有额外开销，性能极高。

结论：jvm不用和操作系统协商设置mutex，它只需要记录线程id就标示自己获得了当前锁，不用操作系统接入。
偏向锁：在没有其它线程竞争的时候，一直偏向偏心当前线程，当前线程可以一直执行。

3.5 偏向锁的开启与关闭

-XX:+UserBiasedLocking  开启偏向锁默认
-XX:-UserBiasedLocking   关闭偏向锁，会跳级进入轻量级锁

3.6 偏向锁的撤销

偏向锁使用一种等到竞争出现才释放锁的机制，只有当其他线程竞争锁时，持有偏向锁的原来线程才会被撤销。撤销需要等待安全点(该时间点上没有字节码正在执行)，同时检查持有偏向锁的线程是否还在执行。
1.第一个线程正在执行synchronized方法(处于同步块)，它没有执行完，其他线程来抢夺，该偏向锁会被取消掉，并出现锁升级。此时轻量级锁由原持有偏向锁的线程持有，继续执行其同步代码，而正在竞争的线程会进入自旋等待获取该轻量级锁。
2.第一个线程执行完成synchronized反复(退出同步块)，则将对象头设置成无锁状态并撤销偏向锁，重新偏向。

3.7 结论

java15后，废弃了偏向锁。

四  轻量级锁

4.1 轻量级锁

轻量级锁：为了线程在近乎交替执行同步块时提供性能。
目的：在没有多线程竞争的前提下，通过cas减少重量级锁使用操作系统互斥量产生的性能消耗，说白了先自旋，不行才升级。
升级时机：当关闭偏向锁功能或多线程竞争偏向锁会导致偏向锁升级为轻量级锁。

4.2 案例流程

假设线程A已经拿到锁，这时线程B又来抢该对象的锁，由于该对象的锁已经被线程A拿到，当前锁已是偏向锁了。
而线程B在争抢时返现对象头mark word中的线程id不是线程b自己的线程id(而时线程A)，那么B就会进入cas操作希望能获得锁。
此时线程b操作分两种情况：
1.获取成功，直接替换mark word中的线程id，改成b自己的id(A->B),重新偏向于其他线程(即将偏向锁交给其他线程，相当于当前线程被释放了锁)，该锁会保持偏向锁状态，A线程Over，B线程上位。如下图所示：

2.获取失败，则偏向锁升级位轻量级锁(设置偏向锁标识为0并设置标志位为00),此时轻量级锁由原持有偏向锁的线程持有，继续执行其同步代码，而在竞争的线程B会进入自旋等待获得该轻量级锁。如下图所示：

4.3 轻量级锁加锁

1）加锁：jvm会为每个线程在当前线程的栈帧中创建用于存储锁记录的空间，若一个线程获得锁时发现时轻量级锁，会把锁的markword复制到自己的displaced mark word里面，然后线程尝试用cas将锁的markword替换成为锁指向锁记录的指针。
如果成功，当前线程获得锁；如果失败，表示mark word已经被替换成了其他线程的锁记录，说明在与其他线程竞争锁，当前线程就尝试使用自旋来获取锁。
自旋cas：不断尝试去获取锁，能不升级就不往上桶，尽量不要阻塞。
2）轻量级锁的释放
在释放锁时，当前线程会使用cas操作，将displaced mark word的内容复制回锁的mark word里面，如果没有发生竞争，那么这个复制的操作会成功，如果由其他线程因为自旋多次导致轻量级锁升级为重量级锁，那么cas操作会失败，此时会释放锁并唤醒被阻塞的线程

五  重量锁

5.1 重量级锁

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

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

六  总结

6.1  轻量级锁与重量级锁

1.轻量级锁每次退出同步块都需要释放锁，而偏向锁是在竞争发生时才释放锁。

6.2  锁升级后与hashcode关系

 1.在无锁状态下：markword可以存储对象的identity hash code的值，当hashcode方法第一次被调用时，jvm会生成对应的identity hashcode值，并将改值存储到markword中。

2.对于偏向锁：在线程获取偏向锁时，会用Thread ID和epoch值覆盖identity hash code所在的位置。如果一个对象的hashcode方法已经被调用过一次之后，这个对象不能被设置偏向锁。因为如果可以的化，那mark word中的identity hash code必然会偏向线程id给覆盖。这就会造成同一个对象前后两次调用hashcode方法得到的结果不一致。

3.升级为轻量级锁：jvm会在当前线程的栈帧中创建一个锁记录(LOCK  Record)空间，用于存储锁对象的mark word拷贝，该拷贝中可以包含identity hash code，所以轻量级锁可以和identity hash code共存，哈希码和GC年龄都自然保存在此，释放锁会将这些信息写回对象头。

4.升级为重量级锁：mark word保存的重量级锁指针，代表重量级锁的ObjectMoinitor类里，有字段记录非加锁状态下的mark word，锁释放后也会将信息写回到对象头。