Java并发之synchronized关键字深度解析（三）
前言
本篇主要介绍一下synchronized的批量重偏向和批量撤销机制，属于深水区，大家提前备好氧气瓶。
上一篇说完synchronized锁的膨胀过程，下面我们再延伸一下synchronized锁的两种特殊处理，一种是锁的批量重偏向，一种是锁的批量撤销。JVM中有两个参数，BiasedLockingBulkRebiasThreshold和BiasedLockingBulkRevokeThreshold，前者默认阈值为20，控制批量重偏向；后者默认阈值为40，控制批量撤销。下面我们分别看一下它们是如何发挥作用的。
一、批量重偏向
synchronized关键字不支持单个的重偏向，但是可以批量进行。所谓批量重偏向，是指不存在锁竞争的条件下，如果同一个类有50个对象偏向线程t1，而线程t2又分别对这50个对象进行循环加锁，此时t2加锁的前19个对象会膨胀为轻量锁，等到第20个对象时，JVM会预测这个类后面的所有对象都要偏向t2，所以再加锁时，就不会执行锁膨胀了，而是重偏向到线程t2。
只说理论可能大家没什么感知，下面用测试代码来演示一下：
1 package com.mybokeyuan.lockDemo;
2
3 import org.openjdk.jol.info.ClassLayout;
4
5 import java.util.ArrayList;
6 import java.util.List;
7 public class BulkLockClientTest {
8 static List<User> userList = new ArrayList<>();
9 public static void main(String[] args) throws Exception {
10 // 先睡眠5秒，保证开启偏向锁
11 try {
12 Thread.sleep(5000);
13 } catch (InterruptedException e) { // -XX:-UseBiasedLocking
14 e.printStackTrace(); // -XX:BiasedLockingStartupDelay=0
15 }
16 for (int i = 0; i < 50; i++) {
17 userList.add(new User()); // 开启了偏向锁，所以新建的对象都是初始化的偏向锁状态
18 }
19 System.out.println("userList.get(0):");
20 System.out.println(ClassLayout.parseInstance(userList.get(0)).toPrintable());
21
22 Thread t1 = new Thread(() -> {
23 // 循环加锁，加锁后list中的user都是t1线程的偏向锁
24 for (User user : userList) {
25 synchronized (user) {
26 }
27 }
28 try {
29 Thread.sleep(1000000);
30 } catch (InterruptedException e) {
31 e.printStackTrace();
32 }
33 });
34 t1.start();
35 // 保证t1中的for循环结束
36 Thread.sleep(3000);
37 System.out.println("after t1");
38 // 此时打印出来的对象头，全都是偏向t1线程的偏向锁
39 System.out.println(ClassLayout.parseInstance(userList.get(0)).toPrintable());
40
41 Thread t2 = new Thread(() -> {
42 for (int i = 0; i < userList.size(); i++) {
43 // 在t2线程中循环加锁，加到第20个user的时候，会触发批量重偏向，第20个以及后面的对象变为偏向t2线程的偏向锁
44 // 而之前的19个对象仍然为轻量级锁
45 synchronized (userList.get(i)) {
46 if (i == 0 || i == 18 || i == 19 || i == 20) {
47 System.out.println("running t2: " + (i+1));
48 System.out.println(ClassLayout.parseInstance(userList.get(i)).toPrintable());
49 }
50 }
51 }
52
53 });
54 t2.start();
55 }
56 }
结果为：
userList.get(0):
com.mybokeyuan.lockDemo.User object internals:
OFFSET SIZE TYPE DESCRIPTION VALUE
0 4 (object header) 05 00 00 00 (00000101 00000000 00000000 00000000) (5)
4 4 (object header) 00 00 00 00 (00000000 00000000 00000000 00000000) (0)
8 4 (object header) 43 c1 00 20 (01000011 11000001 00000000 00100000) (536920387)
12 1 byte User.age 0
13 3 (alignment/padding gap)
16 4 java.lang.String User.name null
20 4 (loss due to the next object alignment)
Instance size: 24 bytes
Space losses: 3 bytes internal + 4 bytes external = 7 bytes total after t1
com.mybokeyuan.lockDemo.User object internals:
OFFSET SIZE TYPE DESCRIPTION VALUE
0 4 (object header) 05 d8 95 1a (00000101 11011000 10010101 00011010) (446027781)
4 4 (object header) 00 00 00 00 (00000000 00000000 00000000 00000000) (0)
8 4 (object header) 43 c1 00 20 (01000011 11000001 00000000 00100000) (536920387)
12 1 byte User.age 0
13 3 (alignment/padding gap)
16 4 java.lang.String User.name null
20 4 (loss due to the next object alignment)
Instance size: 24 bytes
Space losses: 3 bytes internal + 4 bytes external = 7 bytes total running t2: 1
com.mybokeyuan.lockDemo.User object internals:
OFFSET SIZE TYPE DESCRIPTION VALUE
0 4 (object header) d0 f0 2a 1b (11010000 11110000 00101010 00011011) (455798992)
4 4 (object header) 00 00 00 00 (00000000 00000000 00000000 00000000) (0)
8 4 (object header) 43 c1 00 20 (01000011 11000001 00000000 00100000) (536920387)
12 1 byte User.age 0
13 3 (alignment/padding gap)
16 4 java.lang.String User.name null
20 4 (loss due to the next object alignment)
Instance size: 24 bytes
Space losses: 3 bytes internal + 4 bytes external = 7 bytes total running t2: 19
com.mybokeyuan.lockDemo.User object internals:
OFFSET SIZE TYPE DESCRIPTION VALUE
0 4 (object header) d0 f0 2a 1b (11010000 11110000 00101010 00011011) (455798992)
4 4 (object header) 00 00 00 00 (00000000 00000000 00000000 00000000) (0)
8 4 (object header) 43 c1 00 20 (01000011 11000001 00000000 00100000) (536920387)
12 1 byte User.age 0
13 3 (alignment/padding gap)
16 4 java.lang.String User.name null
20 4 (loss due to the next object alignment)
Instance size: 24 bytes
Space losses: 3 bytes internal + 4 bytes external = 7 bytes total running t2: 20
com.mybokeyuan.lockDemo.User object internals:
OFFSET SIZE TYPE DESCRIPTION VALUE
0 4 (object header) 05 e1 95 1a (00000101 11100001 10010101 00011010) (446030085)
4 4 (object header) 00 00 00 00 (00000000 00000000 00000000 00000000) (0)
8 4 (object header) 43 c1 00 20 (01000011 11000001 00000000 00100000) (536920387)
12 1 byte User.age 0
13 3 (alignment/padding gap)
16 4 java.lang.String User.name null
20 4 (loss due to the next object alignment)
Instance size: 24 bytes
Space losses: 3 bytes internal + 4 bytes external = 7 bytes total running t2: 21
com.mybokeyuan.lockDemo.User object internals:
OFFSET SIZE TYPE DESCRIPTION VALUE
0 4 (object header) 05 e1 95 1a (00000101 11100001 10010101 00011010) (446030085)
4 4 (object header) 00 00 00 00 (00000000 00000000 00000000 00000000) (0)
8 4 (object header) 43 c1 00 20 (01000011 11000001 00000000 00100000) (536920387)
12 1 byte User.age 0
13 3 (alignment/padding gap)
16 4 java.lang.String User.name null
20 4 (loss due to the next object alignment)
Instance size: 24 bytes
Space losses: 3 bytes internal + 4 bytes external = 7 bytes total
可以看到，在t2线程的同步块中，第1到第19个对象仍然是轻量级锁，而到第二十个对象以及后面，全部变为了偏向t2线程的偏向锁。这就是批量重偏向机制。批量重偏向是针对类对象-Class对象设置的，如果同一个类有连续20个对象都被另一个线程同步持有，那么JVM就会放弃膨胀为轻量级锁的处理方式，而是将后面出现的此对象实例重偏向到这个新的线程。
二、批量撤销
假设有80个A类的对象实例，开始时全部偏向线程t1，然后t2线程对第1-40个对象又进行了加锁处理，此时根据批量重定向机制，1-19个对象先是会膨胀为轻量级锁，退出同步块后变为无锁；而第20-40个对象会因为触发批量重定向，锁状态变为偏向t2线程的偏向锁。这时t3线程来了，它对第21-43个对象进行加锁处理（注意t3线程的前20个对象不能跟t2线程的前20个对象重合），这时由于t2线程撤销偏向锁撤销了19次（JVM会按20次计算），t3线程撤销偏向锁撤销了19次（JVM会按20次计算），总共撤销的次数达到了40的阈值，此时JVM会判定为这个A类的对象有问题（不断的切换偏向线程会降低执行效率），从第21-43，都会变为轻量级锁，不再进行重偏向操作，而且会对这个A类的对象关闭偏向的设置，即往后再newA类的对象时，不会进入偏向锁状态，只能走无锁-轻量级锁0重量级锁的膨胀过程。所以批量撤销全称应该为：批量撤销偏向锁。
下面通过模拟代码来展现批量撤销的过程：
1 package com.mybokeyuan.lockDemo;
2
3 import org.openjdk.jol.info.ClassLayout;
4
5 import java.util.ArrayList;
6 import java.util.List;
7 // -XX:+PrintFlagsFinal
8 public class BulkLockClientTest {
9 static List<User> userList = new ArrayList<>();
10 public static void main(String[] args) throws Exception {
11 // 先睡眠5秒，保证开启偏向锁
12 try {
13 Thread.sleep(5000);
14 } catch (InterruptedException e) { // -XX:-UseBiasedLocking
15 e.printStackTrace(); // -XX:BiasedLockingStartupDelay=0
16 }
17 for (int i = 0; i < 80; i++) {
18 userList.add(new User()); // 开启了偏向锁，所以新建的对象都是初始化的偏向锁状态
19 }
20 System.out.println("userList.get(0):");
21 System.out.println(ClassLayout.parseInstance(userList.get(0)).toPrintable());
22
23 Thread t1 = new Thread(() -> {
24 // 循环加锁，加锁后list中的user都是t1线程的偏向锁
25 for (User user : userList) {
26 synchronized (user) {
27 }
28 }
29 try {
30 Thread.sleep(1000000);
31 } catch (InterruptedException e) {
32 e.printStackTrace();
33 }
34 });
35 t1.start();
36 // 保证t1中的for循环结束
37 Thread.sleep(3000);
38 System.out.println("after t1");
39 // 此时打印出来的对象头，全都是偏向t1线程的偏向锁
40 System.out.println(ClassLayout.parseInstance(userList.get(0)).toPrintable());
41
42 Thread t2 = new Thread(() -> {
43 for (int i = 0; i < 40; i++) {
44 // 在t2线程中循环加锁，加到第20个user的时候，会触发批量重偏向，第20个以及后面的对象变为偏向t2线程的偏向锁
45 // 而之前的19个对象仍然为轻量级锁
46 synchronized (userList.get(i)) {
47 if (i == 18) {
48 System.out.println("running t2: " + (i+1));
49 System.out.println(ClassLayout.parseInstance(userList.get(i)).toPrintable());
50 }
51 }
52 }
53 try {
54 Thread.sleep(1000000);
55 } catch (InterruptedException e) {
56 e.printStackTrace();
57 }
58 });
59 t2.start();
60 Thread.sleep(3000);
61 System.out.println("after t2");
62 System.out.println(ClassLayout.parseInstance(new User()).toPrintable());
63
64 Thread t3 = new Thread(() -> {
65 for (int i = 20; i < 43; i++) {
66 // 在t3线程中循环加锁，加到第20个user的时候，会触发批量重偏向，第20个以及后面的对象变为偏向t2线程的偏向锁
67 // 而之前的19个对象仍然为轻量级锁
68 synchronized (userList.get(i)) {
69 if (i == 30 || i == 42) {
70 System.out.println("running t3: " + (i+1));
71 System.out.println(ClassLayout.parseInstance(userList.get(i)).toPrintable());
72 }
73 }
74 }
75 try {
76 Thread.sleep(1000000);
77 } catch (InterruptedException e) {
78 e.printStackTrace();
79 }
80 });
81 t3.start();
82 Thread.sleep(3000);
83 System.out.println("after t3");
84 System.out.println(ClassLayout.parseInstance(new User()).toPrintable());
85 }
86 }
打印结果：
userList.get(0):
com.mybokeyuan.lockDemo.User object internals:
OFFSET SIZE TYPE DESCRIPTION VALUE
0 4 (object header) 05 00 00 00 (00000101 00000000 00000000 00000000) (5)
4 4 (object header) 00 00 00 00 (00000000 00000000 00000000 00000000) (0)
8 4 (object header) 43 c1 00 20 (01000011 11000001 00000000 00100000) (536920387)
12 1 byte User.age 0
13 3 (alignment/padding gap)
16 4 java.lang.String User.name null
20 4 (loss due to the next object alignment)
Instance size: 24 bytes
Space losses: 3 bytes internal + 4 bytes external = 7 bytes total after t1
com.mybokeyuan.lockDemo.User object internals:
OFFSET SIZE TYPE DESCRIPTION VALUE
0 4 (object header) 05 f0 1d 1b (00000101 11110000 00011101 00011011) (454946821)
4 4 (object header) 00 00 00 00 (00000000 00000000 00000000 00000000) (0)
8 4 (object header) 43 c1 00 20 (01000011 11000001 00000000 00100000) (536920387)
12 1 byte User.age 0
13 3 (alignment/padding gap)
16 4 java.lang.String User.name null
20 4 (loss due to the next object alignment)
Instance size: 24 bytes
Space losses: 3 bytes internal + 4 bytes external = 7 bytes total running t2: 19
com.mybokeyuan.lockDemo.User object internals:
OFFSET SIZE TYPE DESCRIPTION VALUE
0 4 (object header) b0 ef bd 1b (10110000 11101111 10111101 00011011) (465432496)
4 4 (object header) 00 00 00 00 (00000000 00000000 00000000 00000000) (0)
8 4 (object header) 43 c1 00 20 (01000011 11000001 00000000 00100000) (536920387)
12 1 byte User.age 0
13 3 (alignment/padding gap)
16 4 java.lang.String User.name null
20 4 (loss due to the next object alignment)
Instance size: 24 bytes
Space losses: 3 bytes internal + 4 bytes external = 7 bytes total after t2
com.mybokeyuan.lockDemo.User object internals:
OFFSET SIZE TYPE DESCRIPTION VALUE
0 4 (object header) 05 01 00 00 (00000101 00000001 00000000 00000000) (261)
4 4 (object header) 00 00 00 00 (00000000 00000000 00000000 00000000) (0)
8 4 (object header) 43 c1 00 20 (01000011 11000001 00000000 00100000) (536920387)
12 1 byte User.age 0
13 3 (alignment/padding gap)
16 4 java.lang.String User.name null
20 4 (loss due to the next object alignment)
Instance size: 24 bytes
Space losses: 3 bytes internal + 4 bytes external = 7 bytes total running t3: 31
com.mybokeyuan.lockDemo.User object internals:
OFFSET SIZE TYPE DESCRIPTION VALUE
0 4 (object header) 90 f4 cd 1b (10010000 11110100 11001101 00011011) (466482320)
4 4 (object header) 00 00 00 00 (00000000 00000000 00000000 00000000) (0)
8 4 (object header) 43 c1 00 20 (01000011 11000001 00000000 00100000) (536920387)
12 1 byte User.age 0
13 3 (alignment/padding gap)
16 4 java.lang.String User.name null
20 4 (loss due to the next object alignment)
Instance size: 24 bytes
Space losses: 3 bytes internal + 4 bytes external = 7 bytes total running t3: 43
com.mybokeyuan.lockDemo.User object internals:
OFFSET SIZE TYPE DESCRIPTION VALUE
0 4 (object header) 90 f4 cd 1b (10010000 11110100 11001101 00011011) (466482320)
4 4 (object header) 00 00 00 00 (00000000 00000000 00000000 00000000) (0)
8 4 (object header) 43 c1 00 20 (01000011 11000001 00000000 00100000) (536920387)
12 1 byte User.age 0
13 3 (alignment/padding gap)
16 4 java.lang.String User.name null
20 4 (loss due to the next object alignment)
Instance size: 24 bytes
Space losses: 3 bytes internal + 4 bytes external = 7 bytes total after t3
com.mybokeyuan.lockDemo.User object internals:
OFFSET SIZE TYPE DESCRIPTION VALUE
0 4 (object header) 01 00 00 00 (00000001 00000000 00000000 00000000) (1)
4 4 (object header) 00 00 00 00 (00000000 00000000 00000000 00000000) (0)
8 4 (object header) 43 c1 00 20 (01000011 11000001 00000000 00100000) (536920387)
12 1 byte User.age 0
13 3 (alignment/padding gap)
16 4 java.lang.String User.name null
20 4 (loss due to the next object alignment)
Instance size: 24 bytes
Space losses: 3 bytes internal + 4 bytes external = 7 bytes total
批量撤销触发的逻辑图如下所示：
后记
好了，synchronized的相关知识就到这里了，这个小系列的三篇，从使用场景，到锁类型的追踪、膨胀过程，再到批量重定向和批量撤销，都进行了说明。再延伸的话无非就是synchronized与volatile关键字的异同点比对之类的，没啥意思，大家百度一下即可。寒冷的冬天，还是要多加学习！
Java并发之synchronized关键字深度解析（三）的更多相关文章
- Java并发之synchronized关键字深度解析（二）
前言 本文继续[Java并发之synchronized关键字深度解析(一)]一文而来,着重介绍synchronized几种锁的特性. 一.对象头结构及锁状态标识 synchronized关键字是如何实 ...
- Java并发之synchronized关键字深度解析（一）
前言 近期研读路神之绝世武学,徜徉于浩瀚无垠知识之海洋,偶有攫取吉光片羽,惶恐未领略其精髓即隐入岁月深处,遂急忙记录一二,顺备来日吹cow之谈资.本小系列为并发之亲儿子-独臂狂侠synchronize ...
- Java并发之synchronized关键字
上篇文章我们主要介绍了并发的基本思想以及线程的基本知识,通过多线程我们可以实现对计算机资源的充分利用,但是在最后我们也说明了多线程给程序带来的两种典型的问题,针对它们,synchronize ...
- Java并发之synchronized关键字和Lock接口
欢迎点赞阅读,一同学习交流,有疑问请留言 . GitHub上也有开源 JavaHouse,欢迎star 引用 当开发过程中,我们遇到并发问题.怎么解决? 一种解决方式,简单粗暴:上锁.将千军万马都给拦 ...
- 深入理解Java并发之synchronized实现原理
深入理解Java类型信息(Class对象)与反射机制 深入理解Java枚举类型(enum) 深入理解Java注解类型(@Annotation) 深入理解Java类加载器(ClassLoader) 深入 ...
- 巨人大哥谈Java中的Synchronized关键字用法
巨人大哥谈Java中的Synchronized关键字用法 认识synchronized 对于写多线程程序的人来说,经常碰到的就是并发问题,对于容易出现并发问题的地方价格synchronized基本上就 ...
- 并发之synchronized关键字的应用
并发之synchronized关键字的应用 synchronized关键字理论基础 前两章我们学习了下java内存模型的相关知识, 现在我们来讲讲逢并发必出现的synchronized关键字. 作用 ...
- Java并发之synchronized
Java多线程同步关键词是常用的多线程同步手段.它可以修饰静态类方法,实例方法,或代码块.修饰static静态方法时是对整个类加锁. 一.实现原理 在JVM中对象内存分三块区域,对象头.实例数据.对齐 ...
- Java进阶1. Synchronized 关键字
Java进阶1. Synchronized 关键字 20131025 1.关于synchronized的简介: Synchronized 关键字代表对这个方法加锁,相当于不管那一个线程,运行到这个方法 ...
随机推荐
- Feature Fusion for Online Mutual Knowledge Distillation （CVPR 2019）
一.解决问题 如何将特征融合与知识蒸馏结合起来,提高模型性能 二.创新点 支持多子网络分支的在线互学习 子网络可以是相同结构也可以是不同结构 应用特征拼接.depthwise+pointwise,将特 ...
- Siamese-RPN论文阅读
https://www.cnblogs.com/zhengyuqian/p/10609737.html
- 2019-9-11：渗透测试，基础学习,vim编辑器，笔记
Linux快捷路径符号说明. 代表当前目录.. 上级目录- 代表前一个工作目录~ 表示当前用户的家目录 vmware tools 用来虚拟机和宿主机之间移动数据 vim/vi编辑器vim编辑器三种模式 ...
- 几行代码轻松搞定python的sqlite3的存取
很简单: 存数据: 1.加载sqlite3驱动(只需一行代码) 2.用驱动执行查询语句(只需一行代码) 取数据: 1.加载sqlite3驱动(只需一行代码) 2.用驱动执行查询语句(只需一行代码) 乍 ...
- /proc/cpuinfo文件解读（超易理解）
在linux系统中,提供了/proc目录下文件,显示系统的软硬件信息.如果想了解系统中CPU的提供商和相关配置信息,则可以查/proc/cpuinfo.但是此文件输出项较多,不易理解.例如我们想获取, ...
- jquery对类的操作,添加,删除,点击添加,再点击删除
jquery对类的操作,添加(addClass),删除l类(remoceClass),点击添加,再点击删除(toggleClass)
- U盘安装centos 7 提示 “Warning: /dev/root does not exist
背景介绍:公司需要使用台式机安装Centos 7.5 系统,来部署一个测试的数据库,在安装Centos 7.5 系统的时候,使用U启安装,但有问题. 提示信息如下 如图:安装centos 7时提示 & ...
- 浅议Grpc传输机制和WCF中的回调机制的代码迁移
浅议Grpc传输机制和WCF中的回调机制的代码迁移 一.引子 如您所知,gRPC是目前比较常见的rpc框架,可以方便的作为服务与服务之间的通信基础设施,为构建微服务体系提供非常强有力的支持. 而基于. ...
- luogu P2783 有机化学之神偶尔会做作弊 |Tarjan+LCA
题目背景 XS中学化学竞赛组教练是一个酷爱炉石的人. 有一天他一边搓炉石一边监考,而你作为一个信息竞赛的大神也来凑热闹. 然而你的化竞基友却向你求助了. "第1354题怎么做"&l ...
- iPhone唯一标识符
为了区分iPhone设备,就要用到iPhone的唯一标识符唯一标识符包括:UDID(唯一设备标识符).identifierForVendor(供应商标识符).advertisingIdentifier ...