对黑马视频synchronized原理进阶与优化实验结果的一点疑惑与解释

最新推荐文章于 2024-09-21 10:38:43 发布

.idea

最新推荐文章于 2024-09-21 10:38:43 发布

阅读量214

点赞数 2

分类专栏：高并发与多线程文章标签：多线程 java synchronized

本文链接：https://blog.csdn.net/m0_46550452/article/details/113825349

版权

高并发与多线程专栏收录该内容

3 篇文章 0 订阅

订阅专栏

前置理解：

Java对象头中Mark Word组成
轻量级锁、CAS（Compare and Swap）
偏向锁（锁重入下轻量级锁对CAS的优化）
重量级锁（锁膨胀下轻量级锁的选择）

代码：

 /**
 * @author 24208
 */
public class Main01 {
    static Thread t1, t2, t3;

    public static void main(String[] args) throws InterruptedException {
        test4();
    }

    private static void test4() throws InterruptedException {
        Vector<Dog> list = new Vector<>();
        int loopNumber = 39;
        /**
         * 创建三个线程t1,t1,t3；t1线程首先循环创建39个dog对象并存入list集合当中，
         * 同时加上锁打印出该对象头中Mark Word的二进制数。循环结束后唤醒t2
         */
        t1 = new Thread(() -> {
            for (int i = 0; i < loopNumber; i++) {
                Dog d = new Dog();
                list.add(d);
                synchronized (d) {
                    log.debug(i + "\t" + ClassLayout.parseInstance(d).toPrintableSimple(true));
                }
            }
            LockSupport.unpark(t2);
        }, "t1");
        t1.start();
        /**
         * 从list集合中取出dog对象，重新加锁，打印加锁前中后的Mark Word。循环结束唤醒t3
         */
        t2 = new Thread(() -> {
            LockSupport.park();
            log.debug("===============> ");
            for (int i = 0; i < loopNumber; i++) {
                Dog d = list.get(i);
                log.debug(i + "\t" + ClassLayout.parseInstance(d).toPrintableSimple(true));
                synchronized (d) {
                    log.debug(i + "\t" + ClassLayout.parseInstance(d).toPrintableSimple(true));
                }
                log.debug(i + "\t" + ClassLayout.parseInstance(d).toPrintableSimple(true));
            }
            LockSupport.unpark(t3);
        }, "t2");
        t2.start();
        /**
         * 与t2同理
         */
        t3 = new Thread(() -> {
            LockSupport.park();
            log.debug("===============> ");
            for (int i = 0; i < loopNumber; i++) {
                Dog d = list.get(i);
                log.debug(i + "\t" + ClassLayout.parseInstance(d).toPrintableSimple(true));
                synchronized (d) {
                    log.debug(i + "\t" + ClassLayout.parseInstance(d).toPrintableSimple(true));
                }
                log.debug(i + "\t" + ClassLayout.parseInstance(d).toPrintableSimple(true));
            }
        }, "t3");
        t3.start();
        t3.join();
        //输出新建的第40个对象的Mark Word
        log.debug(ClassLayout.parseInstance(new Dog()).toPrintableSimple(true));
    }
}

偏向锁默认开启。
当撤销偏向锁阈值达到20次时（撤销次数先加再判断），JVM会这样觉得，我是不是偏向错了呢，于是从第20次加锁开始会在给这些对象加锁时重新偏向至加锁线程。
当撤销偏向锁阈值达到40次时，JVM会这样觉得，自己确实偏向错了，根本就不该偏向。于是整个类的所有对象都会变为不可偏向的，新建的对象也是不可偏向的。

实验结果不便截图只好口述：

在以上的实验代码中，t1阶段所有对象的锁都是偏向t1的偏向锁；t2阶段，前19个偏向锁依次被撤销，加锁时加上的是轻量级锁，而后的20个偏向锁会批量重偏向到t2线程；t3阶段，前19个dog对象由于原本无锁故直接加上轻量级锁，后20个dog对象由于原本偏向的是t2线程，现需要撤销该偏向锁。
整个过程下来撤销偏向锁阈值已经达到了39次，从第40次撤销操作开始，该类对象都将默认不加上偏向锁。

整个实验结果存在的最大的疑惑是！——
在这里插入图片描述既然如此！那么t3过程中的后20个t2偏向锁为什么不发生批量重偏向到t3呢！反而是进行锁升级到轻量级锁！！？

解释不通，穿越时空！

莫非已经重偏向过的锁无法再次进行重偏向？
原来啊，重偏向有个条件之一是需要锁对象的epoch字段 != 类的epoch，当第一次重偏向时已经将类的epoch更新了，同时还遍历对象中的epoch字段，将其改为和类字段一样。此时t3尝试批量重偏向时发现epoch字段都一样了，故只能进行锁升级了。

但是！
已经重偏向过的真的就永远无法再次重偏向了？

原来！
Java中是给予了可再次重定向机制的：BiasedLockingDecayTime=25000ms范围内撤销次数没有达到40次，则撤销次数清为0，重新计数。也就是说，以上面的代码为例，如果t2线程执行完毕后sleep 25秒之后再唤醒t3的话，t3中的下标为39的dog对象锁将会再次发生重偏向指向t3。