偏向锁的【批量重偏向与批量撤销】机制

前言

从网上看了很多批量重偏向与批量撤销的介绍，但都一知半解，本着钻研的精神，使用数据进行分析批量重偏向与批量撤销的工作机制。

准备

首先，要先知道偏向锁的偏向锁机制，着重看下撤销机制。
然后，要知道【批量重偏向与批量撤销】的研究对象是Class，即锁对象对应的Class，而非锁对象本身。

// 研究的是对象.class
synchronized(对象) {
}
// 并不是说的这种，这种不考虑
synchronized(对象.class) {
}

如对机制不了解，可以看下这个博客https://blog.csdn.net/sinat_41832255/article/details/89309944

另外几个jvm参数：

-XX:BiasedLockingBulkRebiasThreshold = 20   // 默认偏向锁批量重偏向阈值
-XX:BiasedLockingBulkRevokeThreshold = 40   // 默认偏向锁批量撤销阈值
-XX:+UseBiasedLocking // 使用偏向锁，jdk6之后默认开启
-XX:BiasedLockingStartupDelay = 0 // 延迟偏向时间, 默认不为0，意思为jvm启动多少ms以后开启偏向锁机制（此处设为0，不延迟）

在这里，我把博客中的图拷过来，方便大家思考。

正文

我们主要看下图中的 “是否开启重偏向？” 这个条件分支，来看下什么是重偏向？

重偏向字面理解就是重新偏向，那什么情况下会重新偏向呢

批量重偏向

我们首先要知道的是，锁对象Class刚开始的情况下，是没有开启重偏向的，意思就是 “是否开启重偏向？” 这个分支刚开始的时候是一直走 “否” 的，即会一直撤销偏向锁 ，当达到BiasedLockingBulkRebiasThreshold（20）次数的时候，允许重偏向。

下面我们看下代码

public class TestBiasedLocking {
    public static void main(String[] args) throws DecoderException, InterruptedException {
        // 首先我们创建一个list，来存放锁对象
        List<TestBiasedLocking> list = new LinkedList<>();
        
        // 线程1
        new Thread(() -> {
            for (int i = 0; i < 50; i++) {
                TestBiasedLocking testBiasedLocking = new TestBiasedLocking();
                list.add(testBiasedLocking); // 新建锁对象
                synchronized (testBiasedLocking) {
                    System.out.println("第" + (i + 1) + "次加锁-线程1"); // 50个妹子第一次结婚
                    System.out.println(ClassLayout.parseInstance(testBiasedLocking).toPrintable()); // 打印对象头信息
                }
            }
        }, "线程1").start();
        
        // 让线程1跑一会儿
        Thread.sleep(2000);
        
        // 线程2
        new Thread(() -> {
            for (int i = 0; i < 30; i++) {
                TestBiasedLocking testBiasedLocking = list.get(i);
                synchronized (testBiasedLocking) {
                    System.out.println("第" + (i + 1) + "次加锁-线程2"); // 前30个妹子依次被30个老王看上，前边20个直接离婚了，后边zf有新规定了，20-30的妹子直接把自己的老公都换成了对应的老王
                    System.out.println(ClassLayout.parseInstance(testBiasedLocking).toPrintable()); // 打印对象头信息
                }
            }
        }, "线程2").start();

        LockSupport.park();
    }
}

先解释下是什么意思，这是输出了三次对象信息，第一行就是对象头信息（分为4组，每组8位，查看方式为，组(左-右)，位(右-左)），红框内的最后三位就是最低的三位，即 偏向锁(1bit)+锁标志(2bit)，其他研究下就明白了；

1）【线程1】1-50次加锁都是101，即偏向锁状态；这个没什么问题，线程1首次加的锁，并且没有别的线程竞争，所以对象头是偏向锁状态，对应的Thread Id为线程1.
2）【线程2】1-19加的锁都是轻量级锁，即前19次进行了偏向锁撤销，第20次执行了重偏向，线程id指向线程2；

举个不太形象的例子。比如你结婚了，你就属于你老公的了，但是隔壁老王看上你了（线程2加锁），这个时候你是不能和他在一起的（不可重偏向），除非离婚（撤销偏向锁，升级为轻量级锁，不可再结婚，偏向锁不可逆）；有一天，zf统计发现某个地区离婚太频繁了(阈值BiasedLockingBulkRebiasThreshold)，直接给他们一次换老公的机会（可重偏向），前提是这个机会只给老公不在家的（正在使用的锁对象已经属于正在使用的线程）；
下面我们把例子带入那个数据中，当第19个人离婚后，zf直接给要离婚的人一次换人的机会，所以第20个人就直接把结婚证上的人名换成老王了（Tread Id直接指向线程2），但是前边19个没这待遇了，因为已经离婚了（撤销偏向锁）

批量撤销

后来zf发现，换过老公的这批人，离婚还是那么频繁（重偏向过的锁对象频繁撤销偏向锁），搞我呢？都玩完！给你一次机会了还不满足？这个地区都别给我结婚了以后（该类下的锁对象都不支持偏向锁了，正在运行的也撤销）。

这就是批量撤销的含义，我们代码来演示下

public class TestBiasedLocking {

    public static void main(String[] args) throws DecoderException, InterruptedException {
        // 首先我们创建一个list，来存放锁对象
        List<TestBiasedLocking> list = new LinkedList<>();

        // 线程1
        new Thread(() -> {
            for (int i = 0; i < 50; i++) {
                TestBiasedLocking testBiasedLocking = new TestBiasedLocking();
                list.add(testBiasedLocking); // 新建锁对象
                synchronized (testBiasedLocking) {
                    System.out.println("第" + (i + 1) + "次加锁-线程1"); // 50个妹子第一次结婚
                    System.out.println(ClassLayout.parseInstance(testBiasedLocking).toPrintable());
                }

            }
            LockSupport.park();
        }, "线程1").start();

        // 让线程1跑一会儿
        Thread.sleep(2000);

        // 线程2
        new Thread(() -> {
            for (int i = 0; i < 40; i++) {
                TestBiasedLocking testBiasedLocking = list.get(i);
                synchronized (testBiasedLocking) {
                        System.out.println("第" + (i + 1) + "次加锁-线程2"); // 前40个妹子依次被40个老王看上，前边20个直接离婚了，后边zf有新规定了，20-40的妹子直接把自己的老公都换成了对应的老王
                        System.out.println(ClassLayout.parseInstance(testBiasedLocking).toPrintable());

                }
            }
            LockSupport.park();
        }, "线程2").start();

        // 让线程2跑一会儿
        Thread.sleep(2000);

        // 线程3
        new Thread(() -> {
            for (int i = 20; i < 40; i++) {
                TestBiasedLocking testBiasedLocking = list.get(i);
                synchronized (testBiasedLocking) {
                        System.out.println("第" + (i + 1) + "次加锁-线程3"); // 20-40的妹子觉得很刺激，换过老王了，还想接着换王中王？玩砸了，这个地区的女的以后都不准结婚了，结婚的也都给我离婚
                        System.out.println(ClassLayout.parseInstance(testBiasedLocking).toPrintable());
                }
            }
            LockSupport.park();
        }, "线程3").start();

        // 让线程3跑一会儿
        Thread.sleep(2000);
        System.out.println("刚出生的妹子"); // 生不逢时，政策不一样了，该地区的妹子以后都不让结婚了
        System.out.println(ClassLayout.parseInstance(new TestBiasedLocking()).toPrintable());
        LockSupport.park();
        }
    }

下面我们用通俗的语言来解释下

1) 线程1、1-50都结婚了（有偏向的线程了）
2) 线程2、1-19都离婚了（锁撤销），zf看不行啊，直接结婚证改名吧，20-40都换老公了（Thread Id直接换了） // 到达BiasedLockingBulkRebiasThreshold次数
3) 线程3、20-40又离婚了（锁撤销），滚蛋，都玩完，谁都不能结婚，结婚的也都给我离婚 （设置为不可偏向状态，正在运行的锁对象会被撤销）// 到达BiasedLockingBulkRevokeThreshold次数
4) 刚出生的妹子，以后直接不让结婚了。（new出来就是轻量级锁）

第3点请注意，玩完的条件是这些再次离婚的人频率不是太大，就不会玩完，频率太大就玩完，就是说有一个缓度（批量重偏向后撤销次数达到BiasedLockingBulkRevokeThreshold=40次，就会玩完，但时间-XX:BiasedLockingDecayTime=25000ms范围内没有达到40次，撤销次数清为0，重新计时。）

最后

最后我来解释下文章中出现的举例

1. 这个地区代表什么
答：这个Class （这个地区的女的代表这个class下的所有对象）

2. 怎么判断只有一次换老公的机会的(每个对象是怎么判断只有重偏向的一次机会的？）
答：对象头中偏向锁有个Epoch，该对象对应的Class中也有这个字段，当可偏向的时候，Class中的Epoch+1，正在使用的锁对象Epoch也会+1（老公在家，没有机会换老公），判断可重偏向的时候，Class.Epoch != 对象.Epoch，代表可重偏向。

---

欢迎指正。