在本文讲解以前，先来简单了解一下为何会有批量重偏向和批量撤销。
批量重偏向：当一个线程建立了大量对象并执行了初始的同步操做，后来另外一个线程也来将这些对象做为锁对象进行操做，会导偏向锁重偏向的操做。
批量撤销：在多线程竞争剧烈的状况下，使用偏向锁将会下降效率，因而乎产生了批量撤销机制。
JVM的默认参数值
经过JVM的默认参数值，找一找批量重偏向和批量撤销的阈值。
设置JVM参数-XX:+PrintFlagsFinal，在项目启动时便可输出JVM的默认参数值
intx BiasedLockingBulkRebiasThreshold = 20 默认偏向锁批量重偏向阈值
intx BiasedLockingBulkRevokeThreshold = 40 默认偏向锁批量撤销阈值
固然咱们能够经过-XX:BiasedLockingBulkRebiasThreshold 和 -XX:BiasedLockingBulkRevokeThreshold 来手动设置阈值
批量重偏向
public static void main(String[] args) throws Exception { //延时产生可偏向对象 Thread.sleep(5000); //创造100个偏向线程t1的偏向锁 List<A> listA = new ArrayList<>(); Thread t1 = new Thread(() -> { for (int i = 0; i <100 ; i++) { A a = new A(); synchronized (a){ listA.add(a); } } try { //为了防止JVM线程复用，在建立完对象后，保持线程t1状态为存活 Thread.sleep(100000000); } catch (InterruptedException e) { e.printStackTrace(); } }); t1.start(); //睡眠3s钟保证线程t1建立对象完成 Thread.sleep(3000); out.println("打印t1线程，list中第20个对象的对象头："); out.println((ClassLayout.parseInstance(listA.get(19)).toPrintable())); //建立线程t2竞争线程t1中已经退出同步块的锁 Thread t2 = new Thread(() -> { //这里面只循环了30次！！！ for (int i = 0; i < 30; i++) { A a =listA.get(i); synchronized (a){ //分别打印第19次和第20次偏向锁重偏向结果 if(i==18||i==19){ out.println("第"+ ( i + 1) + "次偏向结果"); out.println((ClassLayout.parseInstance(a).toPrintable())); } } } try { Thread.sleep(10000000); } catch (InterruptedException e) { e.printStackTrace(); } }); t2.start(); Thread.sleep(3000); out.println("打印list中第11个对象的对象头："); out.println((ClassLayout.parseInstance(listA.get(10)).toPrintable())); out.println("打印list中第26个对象的对象头："); out.println((ClassLayout.parseInstance(listA.get(25)).toPrintable())); out.println("打印list中第41个对象的对象头："); out.println((ClassLayout.parseInstance(listA.get(40)).toPrintable())); }
咱们一步一步来分析打印结果
首先，创造了100个偏向线程t1的偏向锁，结果没什么好说的，100个偏向锁嘛，偏向的线程ID信息为531939333
再来看看重偏向的结果，线程t2，前19次偏向均产生了轻量锁，而到第20次的时候，达到了批量重偏向的阈值20，此时锁并非轻量级锁，而变成了偏向锁，此时偏向的线程t2，线程t2的ID信息为5322162821多线程
最后咱们再来看一下偏向结束后的对象头信息。
前20个对象，并无触发了批量重偏向机制，线程t2执行释放同步锁后，转变为无锁形态
第20~30个对象，触发了批量重偏向机制，对象为偏向锁状态，偏向线程t2，线程t2的ID信息为5322162821
而31个对象以后，也没有触发了批量重偏向机制，对象仍偏向线程t1，线程t1的ID信息为531939333
批量撤销
咱们再来看看批量撤销
public static void main(String[] args) throws Exception { Thread.sleep(5000); List<A> listA = new ArrayList<>(); Thread t1 = new Thread(() -> { for (int i = 0; i <100 ; i++) { A a = new A(); synchronized (a){ listA.add(a); } } try { Thread.sleep(100000000); } catch (InterruptedException e) { e.printStackTrace(); } }); t1.start(); Thread.sleep(3000); Thread t2 = new Thread(() -> { //这里循环了40次。达到了批量撤销的阈值 for (int i = 0; i < 40; i++) { A a =listA.get(i); synchronized (a){ } } try { Thread.sleep(10000000); } catch (InterruptedException e) { e.printStackTrace(); } }); t2.start(); //———————————分割线，前面代码再也不赘述—————————————————————————————————————————— Thread.sleep(3000); out.println("打印list中第11个对象的对象头："); out.println((ClassLayout.parseInstance(listA.get(10)).toPrintable())); out.println("打印list中第26个对象的对象头："); out.println((ClassLayout.parseInstance(listA.get(25)).toPrintable())); out.println("打印list中第90个对象的对象头："); out.println((ClassLayout.parseInstance(listA.get(89)).toPrintable())); Thread t3 = new Thread(() -> { for (int i = 20; i < 40; i++) { A a =listA.get(i); synchronized (a){ if(i==20||i==22){ out.println("thread3 第"+ i + "次"); out.println((ClassLayout.parseInstance(a).toPrintable())); } } } }); t3.start(); Thread.sleep(10000); out.println("从新输出新实例A"); out.println((ClassLayout.parseInstance(new A()).toPrintable())); }
来看看输出结果，这部分和上面批量偏向结果的截然不同。重点关注记录的线程ID信息
前20个对象，并无触发了批量重偏向机制，线程t2执行释放同步锁后，转变为无锁形态
第20~40个对象，触发了批量重偏向机制，对象为偏向锁状态，偏向线程t2，线程t2的ID信息为540039429
而41个对象以后，也没有触发了批量重偏向机制，对象仍偏向线程t1，线程t1的ID信息为540002309
重头戏来了！线程t3也来竞争锁。由于已经达到了批量撤销的阈值，且对象listA.get(20)和listA.get(22)已经进行过偏向锁的重偏向，并不会再次重偏向线程t3。
此时触发批量撤销，此时对象锁膨胀变为轻量级锁。
再来看看最后新生成的对象A。值得注意的是：本应该为可偏向状态偏向锁的新对象，在经历过批量重偏向和批量撤销后直接在实例化后转为无锁。优化
简单总结
一、批量重偏向和批量撤销是针对类的优化，和对象无关。
二、偏向锁重偏向一次以后不可再次重偏向。
三、当某个类已经触发批量撤销机制后，JVM会默认当前类产生了严重的问题，剥夺了该类的新实例对象使用偏向锁的权利