偏向锁详解

最新推荐文章于 2024-09-15 17:51:52 发布
最新推荐文章于 2024-09-15 17:51:52 发布
阅读量3.6k 收藏 20
点赞数 6
分类专栏： java8 文章标签： 偏向锁
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ycxzuoxin/article/details/103451330
版权

偏向锁

概念

根据计算机的 二八理论 而言，临界区被访问时，有 80% 的可能是同一个线程，所以偏向锁在这种情况下可以极大的提升 synchronized 关键字的性能

那偏向锁既然这么有用，为何还要提供关闭的功能呢？在竞争频繁的场景下，偏向锁仅仅只会导致 synchronized 关键字的性能降低，因为撤销偏向锁通常会导致 STW 的发生，除非对象都在当前虚拟机栈


文档

可见 synchronized 官方文档最后一个参考文档

官方参考


应用

JVM 设置参数

# 开启偏向锁
-XX:+UseBiasedLocking
# 关闭偏向锁延迟
-XX:BiasedLockingStartupDelay=0
# 查看所有的 JVM 参数
-XX:+PrintFlagsFinal
# 设置重偏向阈值
-XX:BiasedLockingBulkRebiasThreshold=20
# 批量重偏向距离上次批量重偏向的后重置的延迟时间
-XX:BiasedLockingDecayTime=25000
# 设置批量撤销阈值
-XX:BiasedLockingBulkRevokeThreshold=40

在 JVM 启动的时候会有很多线程在后台运行，例如 GC 线程，Finalizer 线程，VM Thread 线程等，会用到很多同步操作，所以在启动的前 4 秒默认创建的对象都不支持偏向，因为有默认参数

-XX:BiasedLockingStartupDelay=4000

请注意加入依赖

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

匿名偏向

public class BiasedLockDemo1 {
    public static void main(String[] args) throws InterruptedException {
        // JVM 虚拟机启动的时候创建
        Model model1 = new Model();
        // 无锁
        System.out.println(ClassLayout.parseInstance(model1).toPrintable());
        Thread.sleep(4001);
        // JVM 启动 4 秒后创建对象
        Model model2 = new Model();
        // 偏向锁
        System.out.println(ClassLayout.parseInstance(model2).toPrintable());
    }
}

由上可见，在对象，在支持偏向之前创建的对象都是无锁状态的，但是在支持偏向后，创建的对象就自动带有偏向标识，但是此时是没有偏向任何线程的，属于一个匿名偏向（anonymously biased）状态，此时对象可以偏向任何一个线程，详情可以参加 bytecodeInterpreter.cpp


偏向

在第一个案例中，我们加一把锁，可以看到不一样的信息

public class BiasedLockDemo2 {
    public static void main(String[] args) throws InterruptedException {
        // JVM 虚拟机启动的时候创建
        Model model1 = new Model();
        // 无锁
        System.out.println(ClassLayout.parseInstance(model1).toPrintable());
        Thread.sleep(4001);
        // JVM 启动 4 秒后创建对象
        Model model2 = new Model();
        // 偏向锁
        System.out.println(ClassLayout.parseInstance(model2).toPrintable());
        synchronized (model2) {
            // 偏向锁
            System.out.println(ClassLayout.parseInstance(model2).toPrintable());
        }
    }
}

可以看到此时对象头有了线程 ID 的信息


偏向锁升级

偏向锁在退出后，如果有另一个线程来竞争锁资源，会升级为轻量级锁

public class BiasedLockDemo2 {
    public static void main(String[] args) throws InterruptedException {
        // JVM 虚拟机启动的时候创建
        Model model1 = new Model();
        // 无锁
        System.out.println(ClassLayout.parseInstance(model1).toPrintable());
        Thread.sleep(4001);
        // JVM 启动 4 秒后创建对象
        Model model2 = new Model();
        // 偏向锁
        System.out.println(ClassLayout.parseInstance(model2).toPrintable());
        synchronized (model2) {
            // 偏向锁
            System.out.println(ClassLayout.parseInstance(model2).toPrintable());
        }
        synchronized (model2) {
            // 偏向锁
            System.out.println(ClassLayout.parseInstance(model2).toPrintable());
        }
        new Thread(() -> {
            synchronized (model2) {
                // 轻量级锁
                System.out.println(ClassLayout.parseInstance(model2).toPrintable());
            }
        }).start();
    }
}

此时可以看见，相同的 main 线程进入的时候，锁没有升级，此时还是偏向锁，但是当其他的线程进入的时候，偏向锁便升级为了轻量级锁，轻量级锁在下面会说，不在这里讨论

如果在偏向锁还没有退出同步代码块的时候，另一个线程来竞争这个锁资源，会直接升级为重量级锁

public class HeavyweightLockDemo {
    public static void main(String[] args) throws InterruptedException {
        Thread.sleep(5000);
        Model model = new Model();
        System.out.println(ClassLayout.parseClass(Model.class).toPrintable());
        Thread t0 = new Thread(() -> {
            synchronized (model) {
                System.out.println("t0 begin 1");
                System.out.println(ClassLayout.parseInstance(model).toPrintable() + "-------------------1");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("t0 begin 2");
                System.out.println(ClassLayout.parseInstance(model).toPrintable() + "-------------------2");
            }
        });
        Thread t1 = new Thread(() -> {
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("t1 begin");
            synchronized (model) {
                System.out.println(ClassLayout.parseInstance(model).toPrintable());
            }
        });
        t0.start();
        t1.start();
    }
}

批量重偏向

当在一批对象偏向一个线程后，如果另一个线程批量去给这批对象进行撤销偏向锁，并升级为轻量级锁，那么虚拟机会在达到一定的阈值时，会将 class 中的 epoch 值改为 01，但是已经创建的对象 epoch 值都为 00，对比两者不同，于是发生重偏向，将同步块内部的对象中的对象头中偏向的线程 ID 指向自己

public class BiasedLockDemo3 {
    // 同步容器
    public static List<Model> list = new ArrayList<>();

    public static void main(String[] args) throws InterruptedException {
        // 检查点
        List<Integer> checkPoint = Arrays.asList(9,19,49);

        Thread.sleep(5000);
        // JVM 启动 4 秒后创建对象
        Thread t0 = new Thread(() -> {
            for (int i = 0; i < 50; i++) {
                Model model = new Model();
                synchronized (model) {
                    // 等待这个是为了展示 epoch 的值
                    if (i == 49) {
                        try {
                            Thread.sleep(10000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    list.add(model);
                    if (checkPoint.contains(i)) {
                        System.out.println();
                        // 偏向锁
                        System.out.println(ClassLayout.parseInstance(model).toPrintable() + "add----------------------" + i);
                    }
                }
            }
        });

        Thread t1 = new Thread(() -> {
            for (int i = 0; i < list.size(); i++) {
                Model model = list.get(i);
                synchronized (model) {
                    if (checkPoint.contains(i)) {
                        System.out.println();
                        // 在 20 个之前都是轻量级锁，在 20 个以及之后是偏向锁
                        System.out.println(ClassLayout.parseInstance(model).toPrintable() + "t1----------------------" + i);
                    }
                }
            }
            try {
                Thread.sleep(10000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            Model model49 = list.get(49);
            synchronized (model49) {
                System.out.println();
                // 故意等着第 49 个对象进来查看 mark word 信息
                // 轻量级锁
                System.out.println(ClassLayout.parseInstance(model49).toPrintable() + "t1----------------------" + 49);
            }
        }, "t1");
        t0.start();
        Thread.sleep(4000);
        t1.start();
        t1.join();
        // 偏向锁，可以看到 epoch 值是在跟着 class 走的
        System.out.println(ClassLayout.parseInstance(new Model()).toPrintable() + "main----------------------");
    }
}

如果我们在重偏向一次后，又进行了第二次重偏向，不同的情况会出现不同的结果，如果第一次重偏向后经历了 25 秒之后，就会重置重偏向的功能，此时，对象又可以被重偏向了

public class BiasedLockDemo4 {
    // 同步容器
    public static List<Model> list = new ArrayList<>();

    public static void main(String[] args) throws InterruptedException {
        // 检查点
        List<Integer> checkPoint = Arrays.asList(9,19,49);

        Thread.sleep(5000);
        // JVM 启动 4 秒后创建对象
        Thread t0 = new Thread(() -> {
            for (int i = 0; i < 50; i++) {
                Model model = new Model();
                synchronized (model) {
                    list.add(model);
                    if (checkPoint.contains(i)) {
                        System.out.println();
                        // 偏向锁
                        System.out.println(ClassLayout.parseInstance(model).toPrintable() + "add----------------------" + i);
                    }
                }
            }
        });

        Runnable runnable = () -> {
            for (int i = 0; i < list.size(); i++) {
                Model model = list.get(i);
                synchronized (model) {
                    if (checkPoint.contains(i)) {
                        System.out.println();
                        // 在 20 个之前都是轻量级锁，在 20 个以及之后是偏向锁
                        System.out.println(ClassLayout.parseInstance(model).toPrintable() + Thread.currentThread().getName() + "----------------------" + i);
                    }
                }
            }
            try {
                Thread.sleep(10000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        };

        Thread t1 = new Thread(runnable);
        Thread t2 = new Thread(runnable);
        t0.start();
        Thread.sleep(4000);
        t1.setName("t1");
        t1.start();
        Thread.sleep(40000);
        t2.setName("t2");
        t2.start();
        // t2 线程中发生重偏向现象
        t2.join();
        // 偏向锁
        System.out.println(ClassLayout.parseInstance(new Model()).toPrintable() + "main----------------------");
    }
}

批量撤销

如果我们在重偏向一次后，又进行了第二次重偏向，如下

public class BiasedLockDemo4 {
    // 同步容器
    public static List<Model> list = new ArrayList<>();

    public static void main(String[] args) throws InterruptedException {
        // 检查点
        List<Integer> checkPoint = Arrays.asList(9,19,49);

        Thread.sleep(5000);
        // JVM 启动 4 秒后创建对象
        Thread t0 = new Thread(() -> {
            for (int i = 0; i < 50; i++) {
                Model model = new Model();
                synchronized (model) {
                    list.add(model);
                    if (checkPoint.contains(i)) {
                        System.out.println();
                        // 偏向锁
                        System.out.println(ClassLayout.parseInstance(model).toPrintable() + "add----------------------" + i);
                    }
                }
            }
        });

        Runnable runnable = () -> {
            for (int i = 0; i < list.size(); i++) {
                Model model = list.get(i);
                synchronized (model) {
                    if (checkPoint.contains(i)) {
                        System.out.println();
                        // 在 20 个之前都是轻量级锁，在 20 个以及之后是偏向锁
                        System.out.println(ClassLayout.parseInstance(model).toPrintable() + Thread.currentThread().getName() + "----------------------" + i);
                    }
                }
            }
            try {
                Thread.sleep(10000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        };

        Thread t1 = new Thread(runnable);
        Thread t2 = new Thread(runnable);
        t0.start();
        Thread.sleep(4000);
        t1.setName("t1");
        t1.start();
        Thread.sleep(4000);
        t2.setName("t2");
        t2.start();
        // t2 线程中并没有发生重偏向现象
        t2.join();
        // 无锁，因为发生了批量撤销
        System.out.println(ClassLayout.parseInstance(new Model()).toPrintable() + "main----------------------");
    }
}

结果可见，是不会发生重偏向效果的，并且如果数量达到了 40 的阈值（同一线程内），就会发生批量撤销，新建的对象将直接是无锁状态而不再是匿名偏向状态，但是我们如果设置为 list 的大小为 30，即使我们增加一个 t3，也不会发生批量撤销，新建的 Model 对象就不会是无锁状态，而是偏向锁状态


注意

经历过 HashCode 计算后的对象，数组对象是无法作为偏向锁的

public class BiasedLockDemo6 {
    public static void main(String[] args) throws InterruptedException {
        // JVM 虚拟机启动的时候创建
        Model[] model1 = new Model[]{new Model()};
        // 无锁
        System.out.println(ClassLayout.parseInstance(model1).toPrintable());
        Thread.sleep(5000);
        // JVM 启动 4 秒后创建对象
        Model[] model2 = new Model[]{new Model()};
        // 无锁
        System.out.println(ClassLayout.parseInstance(model2).toPrintable());
    }
}

public class BiasedLockDemo7 {
    public static void main(String[] args) throws InterruptedException {
        // JVM 虚拟机启动的时候创建
        Model model1 = new Model();
        // 无锁
        System.out.println(ClassLayout.parseInstance(model1).toPrintable());
        Thread.sleep(5000);
        // JVM 启动 4 秒后创建对象
        Model model2 = new Model();
        model2.hashCode();
        // 无锁
        System.out.println(ClassLayout.parseInstance(model2).toPrintable());
    }
}
Zn昕
关注
专栏目录
Java并发-synchronized, 偏向锁, 轻量级锁详解
听雪楼
09-27 1579
synchronized概述 synchronized就是所谓的重量级锁, 但是自从jdk1.6引入了偏向锁, 轻量级锁之后, synchronized就没有那么重了。 synchronized用法 对于普通同步方法，锁是当前实例对象 对于静态同步方法，锁是当前类的Class对象 对于同步方法块，锁是Synchonized括号里配置的对象 synchronized实现原理 任何对象都有一...
java 偏向锁
weixin_42213903的博客
07-23 5703
文章目录偏向锁1、偏向锁是什么2、优缺点优点缺点3、偏向锁怎么获取前提4、偏向锁的撤销5、可重偏向状态(Rebiasable)6、BiasedLockingBulkRebiasThreshold 参数是干什么用的7、到BiasedLockingBulkRevokeThreshold 参数是干什么用的8、执行下方demo需要准备的环境9、总结和猜想10、参考资料LAST、 demo代码 偏向锁 1、...
深入理解Java中的偏向锁、轻量级锁与重量级锁
最新发布
qq_42798343的博客
09-15 1231
偏向锁：适用于锁主要被一个线程持有的场景，减少了锁的获取与释放开销。轻量级锁：适用于锁被少量线程竞争的场景，通过CAS操作实现快速的锁获取。重量级锁：适用于锁被高频率、多线程竞争的场景，确保锁的独占性。通过合理理解和应用这些锁机制，结合良好的并发编程实践，可以显著提升Java应用程序的性能和响应性。同时，随着Java版本的不断演进，锁的优化机制也在持续改进，开发者应及时关注最新的JVM优化技术，以充分利用其带来的性能优势。
java锁-偏向锁
weixin_39048143的博客
12-12 484
偏向锁: HotSpot作者发现,大多数情况下,锁不仅不存在多线程竞争,而且总是由同一线程多次获得,为了让线程获取锁的代价更低,引入了偏向锁,当一个线程访问同步块并获取锁时,会在对象头和栈贞中的锁记录里存储锁偏向的线程id,以后该线程进入和退出该同步块时,不需要进行CAS操作来获取和释放锁,只需简单的测试一下对象头的Mark Word里是否存储着指向当前线程的偏向锁,如果测试成功,表明线程已经获得...
偏向锁
maqingbin8888的专栏
11-06 744
synchronized  在MarkWord中 设置偏向1 老大说，这叫偏向锁，在没有别的线程竞争的时候，一直偏向我，可以让我一直执行下去轻量级锁  在竞争不激烈的时候，稍微自旋等待一下就能获得锁重量级锁，也是我最为期待的锁，那就是出现了激烈的竞争...
Java偏向锁详解与优化技术
"这篇博客文章探讨了一种名为‘偏向锁’的优化技术，它用于减少Java编程语言中多线程同步相关的原子操作。作者Kenneth Russell和David Detlefs介绍了如何通过消除无竞争条件下的对象监视器同步原语的原子操作来提高...
java锁详解.pdf
12-31
Java 锁详解 Java 锁是 Java 并发编程中的一种基本机制，用于确保线程安全和避免竞争条件。Java 锁可以分为两大类：synchronized 锁和 ReentrantLock 锁。 一、Synchronized 锁 1. 锁的原理：synchronized 锁是...
（二）偏向锁详解
守夜人
11-15 3557
偏向锁详解 （一）路线 默认对象走的是第一条线，先无锁，然后轻量级锁，如下图 （二）为什么不走偏向锁呢 1.因为偏向锁启动有一个延迟 4s后起作用 例如，我们先让线程睡眠5s 然后运行 2.为什么刚开始New出来的对象就是偏向锁？ 偏向锁一旦启动后，这时候New出来的对象就是匿名偏向 ，就是说他已经就是偏向锁了，但是没有线程ID，里面空的。有线程来抢，将自己的ID贴出来，就是偏向锁 （二）为什么要延迟4s 1.你启动偏向锁效率一定会高吗？为什么？ 偏向锁（不太需要竞争的，一般一个线程） 未必会提高
synchronized详解及偏向锁、轻量级锁、自旋锁、重量级锁
dekulugu的博客
10-05 848
要了解synchronized的原理及应用场景就得先了解并发编程是什么，对并发编程不了解的话可以看看这篇博客：https://blog.csdn.net/dekulugu/article/details/108754623 一、synchronized的基本使用 为什么要使用synchronized？ 在并发编程中存在线程安全问题，主要原因有：1.存在共享数据 2.多线程共同操作共享数据。synchronized关键字可以保证在同一时刻，只有一个线程可以执行某个方法或代码块，同时synchronized
偏向锁理解
qq_29499107的博客
04-27 2286
java对象的结构这里简单的说一下：对象头，对象实际数据，对齐填充。 对象头：包含两部分 1：MarkWord （自身运行数据） ,2：类型指针 # markWord: hash码，对象所属的年代，线程持有的锁对象，锁状态标志，偏向线程ID，偏向时间等 状态的不同，markword存储的内容也是不同的。（那么读者很有可能会思考一个问题，那原来的数据比如hash码，分代年龄...
25 张图 | 深入浅出「偏向锁」
程序员高级码农的博客
01-27 1096
偏向锁可能就这样的走完了它的一生，有些同学可能直接发问，都被 deprecated 了，JDK都 17 了，还讲这么多干什么？java 任它发，我用 Java8，这是很多主流的状态，至少你用的版本没有被 deprecated面试还是会被经常问到万一哪天有更好的设计方案，“偏向锁”又以新的形式回来了呢，了解变化才能更好理解背后设计奥卡姆剃刀原理，我们现实中的优化也一样，如果没有必要不要增加实体，如果增加的内容带来很大的成本，不如大胆的废除掉，接受一点落差。
Java偏向锁实现原理(Biased Locking)
miyao16的专栏
11-30 1068
阅读本文的读者，需要对Java轻量级锁有一定的了解，知道lock record, mark word之类的名词。可以参考我的一篇博文：Java轻量级锁原理详解（Lightweight Locking）Java偏向锁(Biased Locking)是Java6引入的一项多线程优化。它通过消除资源无竞争情况下的同步原语，进一步提高了程序的运行性能。轻量级锁也是一种多线程优化，它与偏向锁的区
锁的优化（偏向锁、轻量级锁、重量级锁，CAS）
sophia__yu的博客
11-18 4095
为什么出现CAS？ 我们知道synchronized关键字不论是实现同步方法还是同步代码块，都需要首先执行monitorenter获取到锁对象的监视器monitor,同一时刻只有一个线程可以获取到锁对象的monitor监听器，退出时需要执行monitorexit进行解锁。 monitor机制是JDK1.6之前synchronized（内建锁）底层原理，又称为JDK1.6重量级锁。线程的阻塞和唤醒均...
偏向锁、轻量级锁和重量级锁
记录各种Bug解决案例及日常学习内容
05-19 5329
为什么会有偏向锁、轻量级锁和重量级锁? 并发锁总共有4种状态：无锁状态、偏向锁状态、轻量级锁状态和重量级锁状态，每种状态在并发竞争情况下需要消耗的资源由低到高，性能由高到低。重量级锁需要通过操作系统在用户态与核心态之间切换，就像它的名字是一个重量级操作，这也是synchronized效率不高的原因，JDK1.6对synchronized进行了优化，引入了偏向锁与轻量级锁，提高了性能降低了资源消耗。 什么是偏向锁？ 通过对大量数据的分析可以发现，大多数情况下锁竞争是不会发生的，往往是一个线程多次获得同一个锁，
偏向锁、轻量级锁、重量级锁
Mamba Out
07-18 643
偏向锁只有遇到其他线程尝试竞争偏向锁时，持有偏向锁的线程才会释放锁，线程不会主动释放偏向锁。在代码进入同步块的时候，如果同步对象锁状态为无锁状态（锁标志位为“01”状态，是否为偏向锁为“0”），虚拟机首先将在当前线程的栈帧中建立一个名为锁记录（LockRecord）的空间，用于存储锁对象目前的MarkWord的拷贝，然后拷贝对象头中的MarkWord复制到锁记录中。是指当锁是偏向锁的时候，被另外的线程所访问，偏向锁就会升级为轻量级锁，其他线程会通过自旋的形式尝试获取锁，不会阻塞，从而提高性能。......
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值