偏向锁详解

最新推荐文章于 2024-06-26 17:30:44 发布
最新推荐文章于 2024-06-26 17:30:44 发布
阅读量3.5k 收藏 19
点赞数 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 偏向锁
weixin_42213903的博客
07-23 5677
文章目录偏向锁1、偏向锁是什么2、优缺点优点缺点3、偏向锁怎么获取前提4、偏向锁的撤销5、可重偏向状态(Rebiasable)6、BiasedLockingBulkRebiasThreshold 参数是干什么用的7、到BiasedLockingBulkRevokeThreshold 参数是干什么用的8、执行下方demo需要准备的环境9、总结和猜想10、参考资料LAST、 demo代码 偏向锁 1、...
Java并发-synchronized, 偏向锁, 轻量级锁详解
听雪楼
09-27 1547
synchronized概述 synchronized就是所谓的重量级锁, 但是自从jdk1.6引入了偏向锁, 轻量级锁之后, synchronized就没有那么重了。 synchronized用法 对于普通同步方法，锁是当前实例对象 对于静态同步方法，锁是当前类的Class对象 对于同步方法块，锁是Synchonized括号里配置的对象 synchronized实现原理 任何对象都有一...
java锁-偏向锁
weixin_39048143的博客
12-12 469
偏向锁: HotSpot作者发现,大多数情况下,锁不仅不存在多线程竞争,而且总是由同一线程多次获得,为了让线程获取锁的代价更低,引入了偏向锁,当一个线程访问同步块并获取锁时,会在对象头和栈贞中的锁记录里存储锁偏向的线程id,以后该线程进入和退出该同步块时,不需要进行CAS操作来获取和释放锁,只需简单的测试一下对象头的Mark Word里是否存储着指向当前线程的偏向锁,如果测试成功,表明线程已经获得...
Java多线程三——偏向锁/轻量级锁/重量级锁详解
最新发布
w1475995549的博客
06-26 1296
详细介绍了偏向锁/轻量级锁/重量级锁的加锁和解锁过程，以及偏向锁——>轻量级锁——>重量级锁的锁膨胀过程
偏向锁
热门推荐
sinat
04-15 15万+
流程讲解 当JVM启用了偏向锁模式（JDK6以上默认开启），新创建对象的MarkWord中的ThreadId为0，说明此时处于可偏向但未偏向任何线程，也叫做匿名偏向状态(anonymouslybiased)。 偏向锁逻辑 1.线程A第一次访问同步块时，先检测对象头MarkWord中的标志位是否为01，依此判断此时对象锁是否处于无所状态或者偏向锁状态（匿名偏向锁）； 2...
java锁详解.pdf
12-31
Java 锁详解 Java 锁是 Java 并发编程中的一种基本机制，用于确保线程安全和避免竞争条件。Java 锁可以分为两大类：synchronized 锁和 ReentrantLock 锁。 一、Synchronized 锁 1. 锁的原理：synchronized 锁是...
synchronized详解及偏向锁、轻量级锁、自旋锁、重量级锁
dekulugu的博客
10-05 825
要了解synchronized的原理及应用场景就得先了解并发编程是什么，对并发编程不了解的话可以看看这篇博客：https://blog.csdn.net/dekulugu/article/details/108754623 一、synchronized的基本使用 为什么要使用synchronized？ 在并发编程中存在线程安全问题，主要原因有：1.存在共享数据 2.多线程共同操作共享数据。synchronized关键字可以保证在同一时刻，只有一个线程可以执行某个方法或代码块，同时synchronized
Java 锁详解
ycfxhsw的博客
07-06 346
公平锁：是指多个线程按照申请锁的顺序来获取锁，线程直接进入队列中排队，队列中的第一个线程才能获得锁。类似排队打饭，先来后到。非公平锁：是指多个线程获取锁的顺序并不是按照申请锁的顺序，有可能后申请的线程比先申请的线程优先获取锁。公平锁，就是很公平，在并发环境中，每个线程在获取锁时会先查看此锁维护的等待队列，如果为空，或者当前线程是等待队列的第一个，就占有锁，否则就会加入到等待队列中，以后会按照 FIFO 的规则从队列中取到自己。非公平锁，比较粗鲁，上来就直接尝试占有锁，如果尝试失败，就再采用类似公平锁的方式。
java中的锁——偏向锁，轻量级锁，重量级锁
A_BCDEF_的博客
04-21 1797
否则测试Mark Word中偏向锁的标识符是否为1（当前是否为偏向锁，1是0否），如果不是偏向锁则使用CAS竞争锁（使用CAS将对象头的偏向锁指向当前线程），如果是则尝试使用CAS将对象头的偏向锁指向当前线程。偏向锁的撤销，需要等待全局安全点（在这个时间点上没有字节码正在执行），它会首先暂停拥有偏向锁的线程，检查持有偏向锁的线程是否处于活动状态（同步代码块是否执行完），不处于活动状态则将对象头设置为无锁状态，线程可以使用CAS竞争锁。），那么该线程会自动获取锁，降低获取锁的代价。
Java偏向锁实现原理(Biased Locking)
miyao16的专栏
11-30 1040
阅读本文的读者，需要对Java轻量级锁有一定的了解，知道lock record, mark word之类的名词。可以参考我的一篇博文：Java轻量级锁原理详解（Lightweight Locking）Java偏向锁(Biased Locking)是Java6引入的一项多线程优化。它通过消除资源无竞争情况下的同步原语，进一步提高了程序的运行性能。轻量级锁也是一种多线程优化，它与偏向锁的区
偏向锁、轻量级锁和重量级锁
记录各种Bug解决案例及日常学习内容
05-19 5288
为什么会有偏向锁、轻量级锁和重量级锁? 并发锁总共有4种状态：无锁状态、偏向锁状态、轻量级锁状态和重量级锁状态，每种状态在并发竞争情况下需要消耗的资源由低到高，性能由高到低。重量级锁需要通过操作系统在用户态与核心态之间切换，就像它的名字是一个重量级操作，这也是synchronized效率不高的原因，JDK1.6对synchronized进行了优化，引入了偏向锁与轻量级锁，提高了性能降低了资源消耗。 什么是偏向锁？ 通过对大量数据的分析可以发现，大多数情况下锁竞争是不会发生的，往往是一个线程多次获得同一个锁，
偏向锁、轻量级锁、重量级锁
Mamba Out
07-18 622
偏向锁只有遇到其他线程尝试竞争偏向锁时，持有偏向锁的线程才会释放锁，线程不会主动释放偏向锁。在代码进入同步块的时候，如果同步对象锁状态为无锁状态（锁标志位为“01”状态，是否为偏向锁为“0”），虚拟机首先将在当前线程的栈帧中建立一个名为锁记录（LockRecord）的空间，用于存储锁对象目前的MarkWord的拷贝，然后拷贝对象头中的MarkWord复制到锁记录中。是指当锁是偏向锁的时候，被另外的线程所访问，偏向锁就会升级为轻量级锁，其他线程会通过自旋的形式尝试获取锁，不会阻塞，从而提高性能。......
偏向锁状态
搓搓那年时光静好
06-14 828
一个对象创建时， 如果开启了偏向锁(默认开启),那么对象创建后，markword值为0x05即最后3位101,这时它的Thread，epoch，age都为0 偏向锁默认是延迟的，不会在程序启动时立即生效，如果想避免延迟，可以加VM参数-xx:BiaseLockingStartupDelay=0来禁用延迟 如果没有开启偏向锁，那么对象创建后，markword值为0x01即最后3位位001，这时它的hashcode,age,都为0，第一次用到hashcode时才会赋值 ...
【JUC进阶】05. 偏向锁
有一只柴犬的专栏
06-26 3422
偏向锁是Java并发编程中一种重要的锁机制，它针对特定的线程进行优化，从而提高了并发性能。这种锁机制在多线程场景下非常常见，特别适用于一些读写分离的应用场景。
Java偏向锁详解与优化技术
"这篇博客文章探讨了一种名为‘偏向锁’的优化技术，它用于减少Java编程语言中多线程同步相关的原子操作。作者Kenneth Russell和David Detlefs介绍了如何通过消除无竞争条件下的对象监视器同步原语的原子操作来提高...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值