本文主要是介绍java 偏向锁 重偏向_盘一盘 synchronized (二)—— 偏向锁批量重偏向与批量撤销...,希望对大家解决编程问题提供一定的参考价值,需要的开发者们随着小编来一起学习吧!
在本文讲解之前,先来简单了解一下为什么会有批量重偏向和批量撤销。 批量重偏向:当一个线程创建了大量对象并执行了初始的同步操作,后来另一个线程也来将这些对象作为锁对象进行操作,会导偏向锁重偏向的操作。 批量撤销:在多线程竞争剧烈的情况下,使用偏向锁将会降低效率,于是乎产生了批量撤销机制。
JVM的默认参数值
通过JVM的默认参数值,找一找批量重偏向和批量撤销的阈值。 设置JVM参数-XX:+PrintFlagsFinal,在项目启动时即可输出JVM的默认参数值
intx BiasedLockingBulkRebiasThreshold = 20 默认偏向锁批量重偏向阈值 intx BiasedLockingBulkRevokeThreshold = 40 默认偏向锁批量撤销阈值 当然我们可以通过-XX:BiasedLockingBulkRebiasThreshold 和 -XX:BiasedLockingBulkRevokeThreshold 来手动设置阈值
批量重偏向
public static void main(String[] args) throwsException {
//延时产生可偏向对象
Thread.sleep(5000); //创造100个偏向线程t1的偏向锁 List listA = new ArrayList<>(); Thread t1 = new Thread(() ->{ for (int i = 0; i <100 ; i++) { A a = newA(); 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) throwsException {
Thread.sleep(5000); List listA = new ArrayList<>(); Thread t1 = new Thread(() ->{ for (int i = 0; i <100 ; i++) { A a = newA(); 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(newA()).toPrintable())); }
来看看输出结果,这部分和上面批量偏向结果的大相径庭。重点关注记录的线程ID信息 前20个对象,并没有触发了批量重偏向机制,线程t2执行释放同步锁后,转变为无锁形态 第20~40个对象,触发了批量重偏向机制,对象为偏向锁状态,偏向线程t2,线程t2的ID信息为540039429 而41个对象之后,也没有触发了批量重偏向机制,对象仍偏向线程t1,线程t1的ID信息为540002309
再来看看最后新生成的对象A。值得注意的是:本应该为可偏向状态偏向锁的新对象,在经历过批量重偏向和批量撤销后直接在实例化后转为无锁。
简单总结
1、批量重偏向和批量撤销是针对类的优化,和对象无关。 2、偏向锁重偏向一次之后不可再次重偏向。 3、当某个类已经触发批量撤销机制后,JVM会默认当前类产生了严重的问题,剥夺了该类的新实例对象使用偏向
这篇关于java 偏向锁 重偏向_盘一盘 synchronized (二)—— 偏向锁批量重偏向与批量撤销...的文章就介绍到这儿,希望我们推荐的文章对编程师们有所帮助!