Monitor概念
Java对象头
以32位虚拟机为例
普通对象
数组对象
其中Mark Word结构为
64位虚拟机Mark Word
参考资料
https://stackoverflow.com/questions/26357186/what-is-in-java-object-header
原理之Monitor（锁）
Monitor被翻译为监视器或管程
每个Java对象都可以关联一个Monitor对象，如果使用synchronized给对象上锁（重量级）之后，该对象头的Mark Work中就被设置指向Monitor对象的指针
Monitor结构如下
- 刚开始Monitor中Owner为null
- 当Thread-2 执行synchronized(obj)就会将Monitor所有者Owner置为Thread-2，Monitor中只能有一个Owner
- 在Thread-2上锁的过程中，如果Thread-3，Thread-4，Thread-5也来执行synchronized(obj)，就会计入EntryList BLOCKED
- Thread-2执行完同步代码块的内容，然后唤醒EntryList中等待的线程来竞争锁，竞争时是非公平的
- 途中WaitSet中的Thread-0，Thread-1是之前获得过锁，单条件不满足进入WAITING状态的线程，后面讲wait-notify时会分析
注意
- synchronized必须是进入同一个对象的Monitor才有上述的效果
- 不加synchronized的对象不会关联监视器，不遵从上述规则
原理之synchronized
static final Object lock = new Object();
static int counter = 0;
public static void main(String[] args) {
synchronized (lock) {
counter++;
}
}
对应的字节码为
public static void main(java.lang.String[]);
descriptor: ([Ljava/lang/String;)V
flags: ACC_PUBLIC, ACC_STATIC
Code:
stack=2, locals=3, args_size=1
0: getstatic #2 // <- lock引用 （synchronized开始）
3: dup
4: astore_1 // lock引用 -> slot 1
5: monitorenter // 将 lock对象 MarkWord 置为 Monitor 指针
6: getstatic #3 // <- i
9: iconst_1 // 准备常数 1
10: iadd // +1
11: putstatic #3 // -> i
14: aload_1 // <- lock引用
15: monitorexit // 将 lock对象 MarkWord 重置, 唤醒 EntryList
16: goto 24
19: astore_2 // e -> slot 2
20: aload_1 // <- lock引用
21: monitorexit // 将 lock对象 MarkWord 重置, 唤醒 EntryList
22: aload_2 // <- slot 2 (e)
23: athrow // throw e
24: return
Exception table:
from to target type
6 16 19 any
19 22 19 any
LineNumberTable:
line 8: 0
line 9: 6
line 10: 14
line 11: 24
LocalVariableTable:
Start Length Slot Name Signature
0 25 0 args [Ljava/lang/String;
StackMapTable: number_of_entries = 2
frame_type = 255 /* full_frame */
offset_delta = 19
locals = [ class "[Ljava/lang/String;", class java/lang/Object ]
stack = [ class java/lang/Throwable ]
frame_type = 250 /* chop */
offset_delta = 4
注意
方法级别的synchronized不会再直接骂指令中有所体现
synchronized原理进阶
1、轻量级锁
轻量级锁使用的场景：如果一个对象虽然有多线程要加锁，但加锁的时间是错开的（也就是没有竞争），那么可以使用轻量级锁来优化。
轻量级锁对使用者是透明的，语法仍然是synchronized
假设有两个方法同步块，利用同一个对象加锁
static final Object obj = new Object();
public static void method1() {
synchronized( obj ) {
// 同步块 A
method2();
}
}
public static void method2() {
synchronized( obj ) {
// 同步块 B
}
}
- 创建锁记录（Lock Record）对象，每个线程都会包含一个锁记录的结构，内部可以存储锁定对象的Mark Word
- 让锁记录中Object refrence指向锁对象，并尝试用cas替换Object中的Mark Word，将Mark Word的值存入锁记录
- 如果cas替换成功，对象头中存储了
锁记录地址和状态00，表示由该线程给对象加锁，这时图示如下
- 如果cas失败，有两种情况
- 如果是其他线程已经持有了该Object的轻量级锁，这时表明有竞争，进入锁膨胀过程
- 如果是自己执行了synchronized锁重入，那么再添加一条Lock Record作为重入的计数
- 当退出synchronized代码块（解锁时），如果有取值为null的锁记录，表示有重入，表示重入计数减一
- 当退出synchronized代码块（解锁时）锁记录的值补位null，这时使用cas将Mark Word的值回复给对象头
- 成功，则解锁成功
- 失败，说明轻量级锁进行了锁膨胀或已经升级为重量级锁，进入重量级锁解锁流程
2、锁膨胀
如果在尝试加轻量级锁的过程中，cas无法成功，这时一种情况就是有其他线程为此对象加上了重量级锁（有竞争），这时需要进行锁膨胀，将轻量级锁变为重量级锁
tatic Object obj = new Object();
public static void method1() {
synchronized( obj ) {
// 同步块
}
}
-
当Thread-1进行轻量级锁加锁时，Thread-0已经为该对象加了轻量级锁
-
当Thread-1加轻量级锁失败，进入锁膨胀流程
- 即为Object对象申请Monitor锁，让Object指向重量级锁地址
- 然后自己进入Monitor的EntryList BLOCKED
-
当Thread-0退出同步同步块解锁时，使用cas将Mark Word的值恢复给对象头，失败。这时会进入重量级锁流程，即按照Monitor地址找到Monitor对象，设置Owner为null，唤醒EntryList中的BOLCKED线程
3、自旋优化
重量级锁竞争的时候，还可以使用自旋来进行优化，如果当前线程自旋成功（即这时持锁线程已经退出了同步块，释放了锁），这时当前线程就可以避免阻塞。
自旋重试成功的情况
自旋重试失败的情况
- 自旋会占用CPU时间，单核CPU自旋就是浪费，多核CPU自旋才能发挥优势
- 在Java 6 之后自旋锁是自适应的，比如对象刚刚的一次自旋成功过，那么认为这次自旋成功的可能性会高，就多自旋几次；反之，就少自旋甚至不自旋，总之，比较智能
- Java 7 之后不能控制是否开启自旋功能
4、偏向锁
轻量级锁在没有竞争时（只有自己这个线程），每次重入仍然要执行cas操作。
Java 6中引入了偏向锁来做进一步优化：只有第一次使用cas线程id设置到对象的Mark Word头，之后发现这个线程id是自己就表示没有竞争，不用重新cas。之后只要不发生竞争，这个对象就归线程所有
例如：
static final Object obj = new Object();
public static void m1() {
synchronized( obj ) {
// 同步块 A
m2();
}
}
public static void m2() {
synchronized( obj ) {
// 同步块 B
m3();
}
}
public static void m3() {
synchronized( obj ) {
// 同步块 C
}
}
偏向状态
回忆一下对象头格式
一个对象创建时：
- 如果开启了偏向锁（默认开启），那么对象创建后，Mark Word的值为0x05，即最后三位为101，这时它的thread、epoch、age都为0
- 偏向锁是默认延迟的，不会再程序启动时立即生效，如果想要避免延迟，可以加VM参数
-XX:BiasedLockingStartupDelay=0来禁用延迟 - 如果没有开启偏向锁，那么对象创建后，Mark Word的值为0x01，即最后三位为001，这时它的hashcode、age都为0，第一次用到hashcode时才会赋值
1）测试延迟特征
Dog d = new Dog();
ClassLayout classLayout = ClassLayout.parseInstance(d);
log.debug("Mark Word before");
System.out.println(classLayout.toPrintable(d));
try {
Thread.sleep(4000);
} catch (InterruptedException e) {
e.printStackTrace();
}
log.debug("Mark Word before");
System.out.println(classLayout.toPrintable(new Dog()));
输出
2022/03/05-23:52:50.383 [main] c.Dog - synchronized before
sync.test.Dog 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) a4 9b 01 f8 (10100100 10011011 00000001 11111000) (-134112348)
12 4 (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total
2022/03/05-23:52:54.383 [main] c.Dog - synchronized after
sync.test.Dog 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) a4 9b 01 f8 (10100100 10011011 00000001 11111000) (-134112348)
12 4 (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total
在偏向锁延迟启动之前创建的对象Mark Work 结尾还是01结尾，之后创建的对象才是101结尾。
需要说明的是，由于操作系统大小端存储数据的问题，所以需要关注的位置如图示位置
大小端存储
- 大端（存储）模式：是指一个数据的低位字节序的内容放在高地址处，高位字节序存的内容放在低地址处。
- 小端（存储）模式：是指一个数据的低位字节序内容存放在低地址处，高位字节序的内容存放在高地址处。（可以总结为“小小小”即低位、低地址、小端）
如果使用VM参数-XX:BiasedLockingStartupDelay=0则可以关闭偏向锁延迟启动，代码如上，输出
2022/03/06-00:28:45.626 [main] c.Dog - Mark Word before
sync.test.Dog 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) 2d 6b 01 f8 (00101101 01101011 00000001 11111000) (-134124755)
12 4 (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total
2022/03/06-00:28:49.636 [main] c.Dog - Mark Word before
sync.test.Dog 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) 2d 6b 01 f8 (00101101 01101011 00000001 11111000) (-134124755)
12 4 (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total
2）测试偏向锁
Dog d = new Dog();
ClassLayout classLayout = ClassLayout.parseInstance(d);
new Thread(() -> {
log.debug("synchronized before");
System.out.println(classLayout.toPrintable(d));
synchronized (d) {
log.debug("synchronized in");
System.out.println(classLayout.toPrintable(d));
}
log.debug("synchronized after");
System.out.println(classLayout.toPrintable(d));
}, "t1").start();
输出
sync.test.Dog 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) a4 9b 01 f8 (10100100 10011011 00000001 11111000) (-134112348)
12 4 (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total
2022/03/06-00:31:49.943 [t1] c.Dog - synchronized in
sync.test.Dog object internals:
OFFSET SIZE TYPE DESCRIPTION VALUE
0 4 (object header) 05 40 3a 1f (00000101 01000000 00111010 00011111) (523911173)
4 4 (object header) 00 00 00 00 (00000000 00000000 00000000 00000000) (0)
8 4 (object header) a4 9b 01 f8 (10100100 10011011 00000001 11111000) (-134112348)
12 4 (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total
2022/03/06-00:31:49.943 [t1] c.Dog - synchronized after
sync.test.Dog object internals:
OFFSET SIZE TYPE DESCRIPTION VALUE
0 4 (object header) 05 40 3a 1f (00000101 01000000 00111010 00011111) (523911173)
4 4 (object header) 00 00 00 00 (00000000 00000000 00000000 00000000) (0)
8 4 (object header) a4 9b 01 f8 (10100100 10011011 00000001 11111000) (-134112348)
12 4 (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total
注意
处于偏向锁的对象解锁后，线程id仍然存储于对象头中
3）测试禁用
在上面测试代码运行时添VM参数-XX:-UseBiasedLocking禁用偏向锁
输出
sync.test.Dog 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) a4 9b 01 f8 (10100100 10011011 00000001 11111000) (-134112348)
12 4 (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total
2022/03/06-00:34:34.398 [t1] c.Dog - synchronized in
sync.test.Dog object internals:
OFFSET SIZE TYPE DESCRIPTION VALUE
0 4 (object header) 08 f0 22 21 (00001000 11110000 00100010 00100001) (555937800)
4 4 (object header) 00 00 00 00 (00000000 00000000 00000000 00000000) (0)
8 4 (object header) a4 9b 01 f8 (10100100 10011011 00000001 11111000) (-134112348)
12 4 (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total
2022/03/06-00:34:34.398 [t1] c.Dog - synchronized after
sync.test.Dog 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) a4 9b 01 f8 (10100100 10011011 00000001 11111000) (-134112348)
12 4 (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total
4）测试hashCode
- 正常对象一开始是没有hashCode的，第一次调用才生成
插销-调用对象的hashCode
调用了对象的hashCode，但偏向锁的对象Mark Word中存储的是线程id，如果调用hashCode会导致偏向锁被撤销
- 轻量级锁会在锁记录中记录hashCode
- 重量级锁会在Monitor中记录hashCode
在调用hashCode后使用偏向锁，记得去掉-XX:-UseBiasedLocking
输出
sync.test.Dog 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) a4 9b 01 f8 (10100100 10011011 00000001 11111000) (-134112348)
12 4 (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total
1213186462
2022/03/06-00:38:07.855 [t1] c.Dog - synchronized in
sync.test.Dog object internals:
OFFSET SIZE TYPE DESCRIPTION VALUE
0 4 (object header) 68 f4 05 20 (01101000 11110100 00000101 00100000) (537261160)
4 4 (object header) 00 00 00 00 (00000000 00000000 00000000 00000000) (0)
8 4 (object header) a4 9b 01 f8 (10100100 10011011 00000001 11111000) (-134112348)
12 4 (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total
2022/03/06-00:38:07.856 [t1] c.Dog - synchronized after
sync.test.Dog object internals:
OFFSET SIZE TYPE DESCRIPTION VALUE
0 4 (object header) 01 9e c1 4f (00000001 10011110 11000001 01001111) (1338088961)
4 4 (object header) 48 00 00 00 (01001000 00000000 00000000 00000000) (72)
8 4 (object header) a4 9b 01 f8 (10100100 10011011 00000001 11111000) (-134112348)
12 4 (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total
撤销-其他线程使用对象
当其他线程使用偏向锁对象时，会将偏向锁升级为轻量级锁
// 设置偏向锁非延迟启动-XX:BiasedLockingStartupDelay=0
public static void main(String[] args) {
Dog d = new Dog();
ClassLayout classLayout = ClassLayout.parseInstance(d);
new Thread(() -> {
synchronized (d) {
log.debug(classLayout.toPrintable(d));
}
synchronized (DogTest2.class) {
DogTest2.class.notify();
}
// 如果不用 wait/notify 使用join必须打开下面的注释
// 因为：t1线程不能结束，否则地产曾线程可能被jvm重作用与t2线程，低层线程id是一样的
// try {
// System.in.read();
// } catch (IOException e) {
// e.printStackTrace();
// }
}, "t1").start();
new Thread(() -> {
synchronized (DogTest2.class) {
try {
DogTest2.class.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
log.debug(classLayout.toPrintable(d));
synchronized (d) {
log.debug(classLayout.toPrintable(d));
}
log.debug(classLayout.toPrintable(d));
}, "t2").start();
}
输出
2022/03/06-00:46:57.794 [t1] c.DogTest2 - sync.test.Dog object internals:
OFFSET SIZE TYPE DESCRIPTION VALUE
0 4 (object header) 05 40 48 1f (00000101 01000000 01001000 00011111) (524828677)
4 4 (object header) 00 00 00 00 (00000000 00000000 00000000 00000000) (0)
8 4 (object header) a4 9b 01 f8 (10100100 10011011 00000001 11111000) (-134112348)
12 4 (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total
2022/03/06-00:46:57.794 [t2] c.DogTest2 - sync.test.Dog object internals:
OFFSET SIZE TYPE DESCRIPTION VALUE
0 4 (object header) 05 40 48 1f (00000101 01000000 01001000 00011111) (524828677)
4 4 (object header) 00 00 00 00 (00000000 00000000 00000000 00000000) (0)
8 4 (object header) a4 9b 01 f8 (10100100 10011011 00000001 11111000) (-134112348)
12 4 (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total
2022/03/06-00:46:57.794 [t2] c.DogTest2 - sync.test.Dog object internals:
OFFSET SIZE TYPE DESCRIPTION VALUE
0 4 (object header) 38 f5 ee 20 (00111000 11110101 11101110 00100000) (552531256)
4 4 (object header) 00 00 00 00 (00000000 00000000 00000000 00000000) (0)
8 4 (object header) a4 9b 01 f8 (10100100 10011011 00000001 11111000) (-134112348)
12 4 (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total
2022/03/06-00:46:57.794 [t2] c.DogTest2 - sync.test.Dog 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) a4 9b 01 f8 (10100100 10011011 00000001 11111000) (-134112348)
12 4 (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total
撤销-调用wait/notify
wait-notify只有重量级锁才有，所以也会撤销偏向锁状态
// 设置偏向锁非延迟启动-XX:BiasedLockingStartupDelay=0
public static void main(String[] args) {
Dog d = new Dog();
ClassLayout classLayout = ClassLayout.parseInstance(d);
new Thread(() -> {
log.debug(classLayout.toPrintable(d));
synchronized (d) {
try {
d.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
log.debug(classLayout.toPrintable(d));
}, "t1").start();
new Thread(() -> {
try {
TimeUnit.SECONDS.sleep(6);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (d) {
d.notify();
}
log.debug(classLayout.toPrintable(d));
}, "t2").start();
}
输出
2022/03/06-01:03:54.661 [t1] c.DogTest3 - sync.test.Dog 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) a4 9b 01 f8 (10100100 10011011 00000001 11111000) (-134112348)
12 4 (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total
2022/03/06-01:04:00.662 [t1] c.DogTest3 - sync.test.Dog object internals:
OFFSET SIZE TYPE DESCRIPTION VALUE
0 4 (object header) 5a f5 51 1c (01011010 11110101 01010001 00011100) (475133274)
4 4 (object header) 00 00 00 00 (00000000 00000000 00000000 00000000) (0)
8 4 (object header) a4 9b 01 f8 (10100100 10011011 00000001 11111000) (-134112348)
12 4 (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total
2022/03/06-01:04:00.662 [t2] c.DogTest3 - sync.test.Dog object internals:
OFFSET SIZE TYPE DESCRIPTION VALUE
0 4 (object header) 5a f5 51 1c (01011010 11110101 01010001 00011100) (475133274)
4 4 (object header) 00 00 00 00 (00000000 00000000 00000000 00000000) (0)
8 4 (object header) a4 9b 01 f8 (10100100 10011011 00000001 11111000) (-134112348)
12 4 (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total
批量重偏向
如果对象虽然被多个线程访问，但是没有竞争，这是偏向线程t1的对象仍然有机会重新偏向t2，重偏向会重置对象的Thread ID
当撤销偏向锁阈值超过20次之后，jvm会觉得自己是不是做错了，于是会在给这些对象加锁时重新偏向至加锁线程
// 设置偏向锁非延迟启动-XX:BiasedLockingStartupDelay=0
public static void main(String[] args) {
List<Dog> list = new Vector<>();
new Thread(() -> {
for (int i = 0; i < 30; i++) {
Dog d = new Dog();
list.add(d);
synchronized (d) {
log.debug(i + "\t" + ClassLayout.parseInstance(d).toPrintable(d));
}
log.debug(i + "\t" + ClassLayout.parseInstance(d).toPrintable(d));
}
synchronized (list) {
list.notify();
}
}, "t1").start();
new Thread(() -> {
synchronized (list) {
try {
list.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
for (int i = 0; i < 30; i++) {
Dog d = list.get(i);
log.debug(i + "\t" + ClassLayout.parseInstance(d).toPrintable(d));
synchronized (d) {
log.debug(i + "\t" + ClassLayout.parseInstance(d).toPrintable(d));
}
log.debug(i + "\t" + ClassLayout.parseInstance(d).toPrintable(d));
}
}, "t2").start();
}
因为阈值是20，所以额外关注t2线程的i=18，19，20的情况就行了
输出
2022/03/06-01:17:22.917 [t2] c.DogTest3 - 18 sync.test.Dog object internals:
OFFSET SIZE TYPE DESCRIPTION VALUE
0 4 (object header) 05 c8 2e 1f (00000101 11001000 00101110 00011111) (523159557)
4 4 (object header) 00 00 00 00 (00000000 00000000 00000000 00000000) (0)
8 4 (object header) a4 9b 01 f8 (10100100 10011011 00000001 11111000) (-134112348)
12 4 (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total
2022/03/06-01:17:22.917 [t2] c.DogTest3 - 18 sync.test.Dog object internals:
OFFSET SIZE TYPE DESCRIPTION VALUE
0 4 (object header) b0 ee a5 1f (10110000 11101110 10100101 00011111) (530968240)
4 4 (object header) 00 00 00 00 (00000000 00000000 00000000 00000000) (0)
8 4 (object header) a4 9b 01 f8 (10100100 10011011 00000001 11111000) (-134112348)
12 4 (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total
2022/03/06-01:17:22.917 [t2] c.DogTest3 - 18 sync.test.Dog 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) a4 9b 01 f8 (10100100 10011011 00000001 11111000) (-134112348)
12 4 (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total
2022/03/06-01:17:22.917 [t2] c.DogTest3 - 19 sync.test.Dog object internals:
OFFSET SIZE TYPE DESCRIPTION VALUE
0 4 (object header) 05 c8 2e 1f (00000101 11001000 00101110 00011111) (523159557)
4 4 (object header) 00 00 00 00 (00000000 00000000 00000000 00000000) (0)
8 4 (object header) a4 9b 01 f8 (10100100 10011011 00000001 11111000) (-134112348)
12 4 (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total
2022/03/06-01:17:22.918 [t2] c.DogTest3 - 19 sync.test.Dog object internals:
OFFSET SIZE TYPE DESCRIPTION VALUE
0 4 (object header) 05 d9 2e 1f (00000101 11011001 00101110 00011111) (523163909)
4 4 (object header) 00 00 00 00 (00000000 00000000 00000000 00000000) (0)
8 4 (object header) a4 9b 01 f8 (10100100 10011011 00000001 11111000) (-134112348)
12 4 (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total
2022/03/06-01:17:22.918 [t2] c.DogTest3 - 19 sync.test.Dog object internals:
OFFSET SIZE TYPE DESCRIPTION VALUE
0 4 (object header) 05 d9 2e 1f (00000101 11011001 00101110 00011111) (523163909)
4 4 (object header) 00 00 00 00 (00000000 00000000 00000000 00000000) (0)
8 4 (object header) a4 9b 01 f8 (10100100 10011011 00000001 11111000) (-134112348)
12 4 (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total
2022/03/06-01:17:22.918 [t2] c.DogTest3 - 20 sync.test.Dog object internals:
OFFSET SIZE TYPE DESCRIPTION VALUE
0 4 (object header) 05 c8 2e 1f (00000101 11001000 00101110 00011111) (523159557)
4 4 (object header) 00 00 00 00 (00000000 00000000 00000000 00000000) (0)
8 4 (object header) a4 9b 01 f8 (10100100 10011011 00000001 11111000) (-134112348)
12 4 (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total
2022/03/06-01:17:22.918 [t2] c.DogTest3 - 20 sync.test.Dog object internals:
OFFSET SIZE TYPE DESCRIPTION VALUE
0 4 (object header) 05 d9 2e 1f (00000101 11011001 00101110 00011111) (523163909)
4 4 (object header) 00 00 00 00 (00000000 00000000 00000000 00000000) (0)
8 4 (object header) a4 9b 01 f8 (10100100 10011011 00000001 11111000) (-134112348)
12 4 (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total
2022/03/06-01:17:22.918 [t2] c.DogTest3 - 20 sync.test.Dog object internals:
OFFSET SIZE TYPE DESCRIPTION VALUE
0 4 (object header) 05 d9 2e 1f (00000101 11011001 00101110 00011111) (523163909)
4 4 (object header) 00 00 00 00 (00000000 00000000 00000000 00000000) (0)
8 4 (object header) a4 9b 01 f8 (10100100 10011011 00000001 11111000) (-134112348)
12 4 (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total
批量撤销
当撤销偏向锁阈值超过40次之后，jvm也觉得偏向错了，也许根本就不应该偏向。于是整个类的所有对象都会变为不可偏向，新建的对象也不可偏向
static Thread t1, t2, t3;
// 设置偏向锁非延迟启动-XX:BiasedLockingStartupDelay=0
public static void main(String[] args) throws InterruptedException {
int loopNumber = 39;
List<Dog> list = new Vector<>();
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).toPrintable(d));
}
}
LockSupport.unpark(t2);
}, "t1");
t2 = new Thread(() -> {
LockSupport.park();
for (int i = 0; i < loopNumber; i++) {
Dog d = list.get(i);
log.debug(i + "\t" + ClassLayout.parseInstance(d).toPrintable(d));
synchronized (d) {
log.debug(i + "\t" + ClassLayout.parseInstance(d).toPrintable(d));
}
log.debug(i + "\t" + ClassLayout.parseInstance(d).toPrintable(d));
}
LockSupport.unpark(t3);
}, "t2");
t3 = new Thread(() -> {
LockSupport.park();
for (int i = 0; i < loopNumber; i++) {
Dog d = list.get(i);
log.debug(i + "\t" + ClassLayout.parseInstance(d).toPrintable(d));
synchronized (d) {
log.debug(i + "\t" + ClassLayout.parseInstance(d).toPrintable(d));
}
log.debug(i + "\t" + ClassLayout.parseInstance(d).toPrintable(d));
}
}, "t3");
t1.start();
t2.start();
t3.start();
t3.join();
Dog dog = new Dog();
log.debug(ClassLayout.parseInstance(dog).toPrintable(dog));
}
输出
2022/03/06-01:30:38.705 [main] c.DogTest5 - sync.test.Dog 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) a4 9b 01 f8 (10100100 10011011 00000001 11111000) (-134112348)
12 4 (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total
参考资料
https://github.com/farmerjohngit/myblog/issues/12
https://www.cnblogs.com/LemonFive/p/11246086.html
https://www.cnblogs.com/LemonFive/p/11248248.html
偏向锁论文
5、锁消除
@Fork(1)
@BenchmarkMode(Mode.AverageTime)
@Warmup(iterations=3)
@Measurement(iterations=5)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
public class MyBenchmark {
static int x = 0;
@Benchmark
public void a() throws Exception {
x++;
}
@Benchmark
public void b() throws Exception {
Object o = new Object();
synchronized (o) {
x++;
}
}
}
java -jar benchmarks.jar
Benchmark Mode Samples Score Score error Units
c.i.MyBenchmark.a avgt 5 1.542 0.056 ns/op
c.i.MyBenchmark.b avgt 5 1.518 0.091 ns/op
java -XX:-EliminateLocks -jar benchmarks.jar
Benchmark Mode Samples Score Score error Units
c.i.MyBenchmark.a avgt 5 1.507 0.108 ns/op
c.i.MyBenchmark.b avgt 5 16.976 1.572 ns/op
锁粗化
对相同对象多次加锁，导致线程发生多次重入，可以使用锁粗化方式来优化，这不同于之前讲的细分锁的粒度。
536
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
