Skip to content

Latest commit

 

History

History
205 lines (179 loc) · 14.8 KB

11. Synchronized与锁升级.md

File metadata and controls

205 lines (179 loc) · 14.8 KB
Raw

11.1 面试题

  • 谈谈你对Synchronized的理解
  • Sychronized的锁升级你聊聊
  • Synchronized实现原理，monitor对象什么时候生成的？知道monitor的monitorenter和monitorexit这两个是怎么保证同步的嘛？或者说这两个操作计算机底层是如何执行的
  • 偏向锁和轻量级锁有什么区别

11.2 Synchronized的性能变化

  • Java5以前，只有Synchronized，这个是操作系统级别的重量级操作
    • 重量级锁，假如锁的竞争比较激烈的话，性能下降
    • Java 5之前 用户态和内核态之间的转换
      • image.png
  • Java6 之后为了减少获得锁和释放锁所带来的性能消耗，引入了轻量级锁和偏向锁

11.3 Synchronized锁种类及升级步骤

11.3.1 多线程访问情况

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

11.3.2 升级流程

  • Synchronized用的锁是存在Java对象头里的MarkWord中，锁升级功能主要依赖MarkWord中锁标志位和释放偏向锁标志位
  • image.png
  • 锁指向，请牢记
    • 偏向锁：MarkWord存储的是偏向的线程ID
    • 轻量锁：MarkWord存储的是指向线程栈中Lock Record的指针
    • 重量锁：MarkWord存储的是指向堆中的monitor对象（系统互斥量指针）

11.3.3 无锁

image.png

11.3.4 偏锁

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

  • 当一段同步代码一直被同一个线程多次访问，由于只有一个线程那么该线程在后续访问时便会自动获得锁
  • 同一个老顾客来访，直接老规矩行方便

结论：

  • HotSpot的作者经过研究发现，大多数情况下：在多线程情况下，锁不仅不存在多线程竞争，还存在由同一个线程多次获得的情况，偏向锁就是在这种情况下出现的，它的出现是为了解决只有一个线程执行同步时提高性能。
  • 偏向锁会偏向于第一个访问锁的线程，如果在接下来的运行过程中，该锁没有被其他线程访问，则持有偏向锁的线程将永远不需要出发同步。也即偏向锁在资源在没有竞争情况下消除了同步语句，懒得连CAS操作都不做了，直接提高程序性能。

理论落地：

  • image.png

技术实现： image.png 偏向锁JVM命令：

  • image.png

案例演示：

  • 偏向锁默认情况演示---只有一个线程
/**
 * @author Guanghao Wei
 * @create 2023-04-14 14:06
 */
public class SynchronizedUpDemo {

    public static void main(String[] args) {
        /**
         * 这里偏向锁在JDK6以上默认开启，开启后程序启动几秒后才会被激活，可以通过JVM参数来关闭延迟 -XX:BiasedLockingStartupDelay=0
         */
//        try { TimeUnit.SECONDS.sleep(5); } catch (InterruptedException e) { e.printStackTrace(); }
        Object o = new Object();
        synchronized (o) {
            System.out.println(ClassLayout.parseInstance(o).toPrintable());
        }
    }
}

image.png 偏向锁的撤销：

  • 当有另外一个线程逐步来竞争锁的时候，就不能再使用偏向锁了，要升级为轻量级锁，使用的是等到竞争出现才释放锁的机制
  • 竞争线程尝试CAS更新对象头失败，会等到全局安全点（此时不会执行任何代码）撤销偏向锁，同时检查持有偏向锁的线程是否还在执行：
    • 第一个线程正在执行Synchronized方法（处于同步块），它还没有执行完，其他线程来抢夺，该偏向锁会被取消掉并出现锁升级，此时轻量级锁由原来持有偏向锁的线程持有，继续执行同步代码块，而正在竞争的线程会自动进入自旋等待获得该轻量级锁
    • 第一个线程执行完Synchronized（退出同步块），则将对象头设置为无所状态并撤销偏向锁，重新偏向。
    • image.png

题外话：Java15以后逐步废弃偏向锁，需要手动开启------->维护成本高

11.3.5 轻锁

概念：多线程竞争，但是任意时候最多只有一个线程竞争，即不存在锁竞争太激烈的情况，也就没有线程阻塞。 主要作用：有线程来参与锁的竞争，但是获取锁的冲突时间极短---------->本质是自旋锁CAS image.png 轻量锁的获取： image.png image.png 案例演示： image.png 自旋一定程度和次数（Java8 之后是自适应自旋锁------意味着自旋的次数不是固定不变的）：

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

轻量锁和偏向锁的区别：

  • 争夺轻量锁失败时，自旋尝试抢占锁
  • 轻量级锁每次退出同步块都需要释放锁，而偏向锁是在竞争发生时才释放锁

11.3.6 重锁

有大量线程参与锁的竞争，冲突性很高 image.png image.png

11.3.7 小总结

  • 锁升级的过程

20200602120540100.jpg

  • 锁升级后，hashcode去哪儿了?
    • image.png
    • image.png
  • 各种锁优缺点、synchronized锁升级和实现原理
    • image.png

11.4 JIT编译器对锁的优化

11.4.1 JIT

Just In Time Compiler 即时编译器

11.4.2 锁消除

/**
 * @author Guanghao Wei
 * @create 2023-04-14 15:13
 * 锁消除
 * 从JIT角度看想相当于无视他，synchronized(o)不存在了
 * 这个锁对象并没有被共用扩散到其他线程使用
 * 极端的说就是根本没有加锁对象的底层机器码，消除了锁的使用
 */

public class LockClearUpDemo {
    static Object object = new Object();

    public void m1() {
        //锁消除问题，JIT会无视它，synchronized(o)每次new出来的，都不存在了，非正常的
        Object o = new Object();
        synchronized (o) {
            System.out.println("-----------hello LockClearUpDemo" + "\t" + o.hashCode() + "\t" + object.hashCode());
        }
    }

    public static void main(String[] args) {
        LockClearUpDemo lockClearUpDemo = new LockClearUpDemo();
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                lockClearUpDemo.m1();
            }, String.valueOf(i)).start();
        }
    }
}
/**
 * -----------hello LockClearUpDemo	229465744	57319765
 * -----------hello LockClearUpDemo	219013680	57319765
 * -----------hello LockClearUpDemo	1109337020	57319765
 * -----------hello LockClearUpDemo	94808467	57319765
 * -----------hello LockClearUpDemo	973369600	57319765
 * -----------hello LockClearUpDemo	64667370	57319765
 * -----------hello LockClearUpDemo	1201983305	57319765
 * -----------hello LockClearUpDemo	573110659	57319765
 * -----------hello LockClearUpDemo	1863380256	57319765
 * -----------hello LockClearUpDemo	1119787251	57319765
 */

11.4.3 锁粗化

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

    public static void main(String[] args) {
        new Thread(() -> {
            synchronized (objectLock) {
                System.out.println("111111111111");
            }
            synchronized (objectLock) {
                System.out.println("222222222222");
            }
            synchronized (objectLock) {
                System.out.println("333333333333");
            }
            synchronized (objectLock) {
                System.out.println("444444444444");
            }
            //底层JIT的锁粗化优化
            synchronized (objectLock) {
                System.out.println("111111111111");
                System.out.println("222222222222");
                System.out.println("333333333333");
                System.out.println("444444444444");
            }
        }, "t1").start();
    }
}

11.5 小总结

  • 没有锁：自由自在
  • 偏向锁：唯我独尊
  • 轻量锁：楚汉争霸
  • 重量锁：群雄逐鹿