作者:京东零售 刘跃明
Monitor概念
Java对象的内存布局
对象除了我们自定义的一些属性外,还有其它数据,在内存中可以分为三个区域:对象头、实例数据、对齐填充,这三个区域组成起来才是一个完整的对象。
对象头:在JVM中需要大量存储对象,存储时为了实现一些额外的功能,需要在对象中添加一些标记字段用于增强对象功能,这些标记字段组成了对象头。
实例数据:存放类的属性数据信息,包括父类的属性信息。
对齐填充:由于虚拟机要求对象其实地址必须是8字节的整数倍,需要存在填充区域以满足8字节的整数倍,填充数据不是必须存在的,仅仅是为了字节对齐。
图1
Java对象头
JVM中对象头的方式有以下两种(以32位虚拟机为例):
普通对象
Object Header (64 bits) | |
---|---|
Mark Word (32 bits) | Klass Word (32 bits) |
数组对象
Object Header (96 bits) | ||
---|---|---|
Mark Word(32bits) | Klass Word(32bits) | array length(32bits) |
Mark Word
这部分主要用来存储对象自身的运行数据,如hashcode、gc分带年龄等,Mark Word的位长度为JVM的一个Word大小,也就是说32位JVM的Mark Word为32位,64位JVM为64位。为了让一个字大小存储更多的信息,JVM将字的最低两个位设置为标记位,不同标记位下的Mark Word示意如下:
Mark Word (32 bits) | State | ||||
---|---|---|---|---|---|
identity_hashcode:25 | age:4 | biased_lock:1 | lock:2 | Normal | |
thread:23 | epoch:2 | age:4 | biased_lock:1 | lock:2 | Biased |
ptr_to_lock_record:30 | lock:2 | LightweightLocked | |||
ptr_to_heavyweight_monitor:30 | lock:2 | HeavyweightLocked | |||
lock:2 | Marked for GC |
其中各部分的含义如下:
lock: 2位的锁状态标记位,该标记的值不同,整个Mark Word表示的含义不同。
biased_lock | lock | 状态 |
---|---|---|
0 | 01 | 无锁 |
1 | 01 | 偏向锁 |
0 | 00 | 轻量级锁 |
0 | 10 | 重量级锁 |
0 | 11 | GC标记 |
biased_lock: 对象是否启用偏向锁标记,只占1个二进制位,为1时表示对象启用偏向锁,为0时表示对象没有偏向锁。
age: 4位的Java对象年龄,在GC中,如果对象再Survivor区复制一次,年龄增加1,当对象达到设定的阈值时,将会晋升到老年代,默认情况下,并行GC的年龄阈值为15,并发GC的年龄阈值为6,由于age只有4位,所以最大值为15,这就是-XX:MaxTenuringThreshold选项最大值为15的原因。
identity_hashcode: 25位的对象表示Hash码,采用延迟加载技术,调用方法System.idenHashcode()计算,并会将结果写到该对象头中,当对象被锁定时,该值会移动到管程Monitor中。
thread: 持有偏向锁的线程ID。
epoch: 偏向时间戳。
ptr_to_lock_record: 指向栈中锁记录的指针。
ptr_to_heavyweight_monitor: 指向管程Monitor的指针。
Klass Word
这一部分用于存储对象的类型指针,该指针指向它的类元数据,JVM通过这个指针确定对象是哪个类的实例,该指针的位长度为JVM的一个字大小,即32位的JVM为32位,64位的JVM为64位。
array length
如果对象是一个数组,那么对象头还需要有额外的空间用于存储数组的长度,这部分数据的长度也随着JVM架构的不同而不同:32位的JVM长度为32位,64位JVM则为64位。
Monitor原理
Monitor被翻译为监视器或管程
每个Java对象都可以关联一个Monitor对象,如果使用synchronized给对象上锁(重量级)之后,该对象头的Mark Word中就被设置指向Monitor对象的指针。
Monitor结构如下:
图2
•刚开始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中等待的线程来竞争锁,竞争是非公平的,也就是先进并非先获取锁
•图2中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 main([Ljava/lang/String;)V
TRYCATCHBLOCK L0 L1 L2 null
TRYCATCHBLOCK L2 L3 L2 null
L4
LINENUMBER 6 L4
GETSTATIC MyClass03.lock : Ljava/lang/Object;
DUP
ASTORE 1
MONITORENTER //注释1
L0
LINENUMBER 7 L0
GETSTATIC MyClass03.counter : I
ICONST_1
IADD
PUTSTATIC MyClass03.counter : I
L5
LINENUMBER 8 L5
ALOAD 1
MONITOREXIT //注释2
L1
GOTO L6
L2
FRAME FULL [[Ljava/lang/String; java/lang/Object] [java/lang/Throwable]
ASTORE 2
ALOAD 1
MONITOREXIT //注释3
L3
ALOAD 2
ATHROW
L6
LINENUMBER 9 L6
FRAME CHOP 1
RETURN
L7
LOCALVARIABLE args [Ljava/lang/String; L4 L7 0
MAXSTACK = 2
MAXLOCALS = 3
注释1
MONITORENTER的意思为:每个对象都有一个监视锁(Monitor),当Monitor被占用时就会处于锁定状态,线程执行MONITORENTER指令时尝试获取Monitor的所有权,过程如下:
•如果Monitor的进入数为0,则该线程进入Monitor,并将进入数设置为1,该线程即为Monitor的所有者(Owner)
•如果该线程已经占用Monitor,只是重新进入Monitor,则进入Monitor的进入数加1
•如果其它线程已经占用Monitor,则该线程进入阻塞状态,直到Monitor进入数为0,再重新尝试获取Monitor的所有权
注释2
MONITOREXIT的意思为:执行指令时,Monitor的进入数减1,如果减1后进入数为0,该线程退出Monitor,不再是这个Monitor的所有者,其它被Monitor阻塞的线程重新尝试获取Monitor的所有权。
总结
通过注释1和注释2可知,synchronized的实现原理,底层是通过Monitor的对象来完成,其实wait和notify等方法也依赖Monitor,这就是为什么wait和notify方法必须要在同步方法内调用,否则会抛出java.lang.IllegalMonitorStateException的原因。
如果程序正常执行则按上述描述即可完成,如果程序在同步方法内发生异常,代码则会走注释3,在注释3可以看到MONITOREXIT指令,也就是synchronized已经处理异常情况下的退出。
注:方法级别的synchronized不会在字节码指令中有所体现,而是在常量池中增加了ACC_SYNCHRONIZED标识符,JVM就是通过该标识符来实现同步的,方法调用时,JVM会判断方法的ACC_SYNCHRONIZED是否被设置,如果被设置,线程执行方法前会先获取Monitor所有权,执行完方法后再释放Monitor所有权,本质是一样的。
synchronized原理进阶
轻量级锁
轻量级锁的使用场景:如果一个对象虽然有多线程要加锁,但加锁的时间是错开的(也就是没有竞争),那么可以使用轻量级锁来优化。
轻量级锁对使用者是透明的,即语法仍然是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
图3
让锁记录中Object reference指向锁对象,并尝试用cas替换Object的Mark Word,将Mark Word的值存入锁记录
图4
如果cas替换成功,对象头中存储了锁记录地址和状态00,表示由该线程给对象加锁,这是图示如下
图5
如果cas失败,有两种情况
•如果是其它线程已经持有了该Object的轻量级锁,这是表明有竞争,进入锁膨胀过程
•如果是自己线程执行了synchronized锁重入,那么再添加一条Lock Record作为重入的技术
图6
当退出synchronized代码块(解锁时),如果有取值为null的锁记录,表示由重入,这是重置锁记录,表示重入技术减一
图7
当退出synchronized代码块(解锁时),锁记录的值不为null,这时使用cas将Mark Word的值回复给对象头
•成功,则解锁成功
•失败,说明轻量级锁进行了锁膨胀或已经升级为重量级锁,进入重量级锁解锁流程
锁膨胀
如果在尝试加轻量级锁的过程中,CAS操作无法成功,这是一种情况就是有其它线程为此对象加上了轻量级锁(有竞争),这是需要进行锁膨胀,将轻量级锁变为重量级锁。
当Thread-1进行轻量级加锁时,Thread-0已经对该对象加了轻量级锁
图8
这是Thread-1加轻量级锁失败,进入锁膨胀流程
•即为Object对象申请Monitor锁,让Object指向重量级锁地址
•然后自己进入Monitor的EntryList BLOCKED
图9
当Thread-0退出同步块解锁时,使用cas将Mark Word的值恢复给对象头,失败,这是会进入重量级解锁流程,即按照Monitor地址找到Monitor对象,设置Owner为null,唤醒EntryList 中BLOCKED线程
自旋优化
重量级锁竞争的时候,还可以使用自旋来进行优化,如果当前线程自旋成功(即这时候持锁线程已经退出了同步,释放了锁),这是当前线程就可以避免阻塞。
自旋重试成功的情况
线程1(core 1上) | 对象Mark | 线程2(core 2 上) |
---|---|---|
- | 10(重量锁) | - |
访问同步块,获取Monitor | 10(重量锁)重量锁指针 | - |
成功(加锁) | 10(重量锁)重量锁指针 | - |
执行同步块 | 10(重量锁)重量锁指针 | - |
执行同步块 | 10(重量锁)重量锁指针 | 访问同步块,获取Monitor |
执行同步块 | 10(重量锁)重量锁指针 | 自旋重试 |
执行完毕 | 10(重量锁)重量锁指针 | 自旋重试 |
成功(解锁) | 01(无锁) | 自旋重试 |
- | 10(重量锁)重量锁指针 | 成功(加锁) |
- | 10(重量锁)重量锁指针 | 执行同步块 |
- | … | … |
自旋重试失败的情况
线程1(core 1上) | 对象Mark | 线程2(core 2 上) |
---|---|---|
- | 10(重量锁) | - |
访问同步块,获取Monitor | 10(重量锁)重量锁指针 | - |
成功(加锁) | 10(重量锁)重量锁指针 | - |
执行同步块 | 10(重量锁)重量锁指针 | - |
执行同步块 | 10(重量锁)重量锁指针 | 访问同步块,获取Monitor |
执行同步块 | 10(重量锁)重量锁指针 | 自旋重试 |
执行同步块 | 10(重量锁)重量锁指针 | 自旋重试 |
执行同步块 | 10(重量锁)重量锁指针 | 自旋重试 |
执行同步块 | 10(重量锁)重量锁指针 | 阻塞 |
- | … | … |
•自旋会占用CPU时间,单核CPU自旋就是浪费,多核CPU自旋才能发挥优势。
•在Java 6之后自旋锁是自适应的,比如对象刚刚的一次自旋操作成功过,那么认为这次自旋成功的可能性会高,就多自旋几次;反之,就少自旋甚至不自旋,总之,比较智能。
•Java 7之后不能控制是否开启自旋功能。
偏向锁
轻量级锁在没有竞争时(就自己这个线程),每次重入仍然需要执行CAS操作。
Java 6中引入了偏向锁做进一步优化:只有第一次使用CAS将线程ID设置到对象的Mark Word头,之后发现这个线程ID是自己的就表示没有竞争,不用重新CAS,以后只要不发生竞争,这个对象就归该线程所有。
注:
Java 15之后废弃偏向锁,默认是关闭,如果想使用偏向锁,配置-XX:+UseBiasedLocking启动参数。
启动偏向锁之后,偏向锁有一个延迟生效的机制,这是因为JVM启动时会进行一系列的复杂活动,比如装载配置,系统类初始化等等。在这个过程中会使用大量synchronized关键字对对象加锁,且这些锁大多数都不是偏向锁。为了减少初始化时间,JVM默认延时加载偏向锁。这个延时的时间大概为4s左右,具体时间因机器而异。当然我们也可以设置JVM参数 -XX:BiasedLockingStartupDelay=0 来取消延时加载偏向锁。
例如:
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) {
}
}
如果关闭偏向锁,使用轻量锁情况:
图10
开启偏向锁,使用偏向锁情况:
图11
偏向状态
回忆一下对象头格式
Mark Word (32 bits) | State | ||||
---|---|---|---|---|---|
identity_hashcode:25 | age:4 | biased_lock:1 | lock:2 | Normal | |
thread:23 | epoch:2 | age:4 | biased_lock:1 | lock:2 | Biased |
ptr_to_lock_record:30 | lock:2 | LightweightLocked | |||
ptr_to_heavyweight_monitor:30 | lock:2 | HeavyweightLocked | |||
lock:2 | Marked for GC |
一个对象创建时:
•如果开启了偏向锁(默认开启),那么对象创建后,Mark Word值为0x05,也就是最后是3位为101,这是它的thread、epoch、age都为0
•如果没有开启偏向锁,那么对象创建后,Mark Word值为0x01,也就是最后3位为001,这时它的hashcode、age都为0,第一次用到hashcode时才会赋值
我们来验证下,使用jol第三方工具,以及对工具打印对象头做了一个处理,让对象头开起来更简便:
测试代码
public synchronized static void main(String[] args){
log.info("{}", toSimplePrintable(object));
}
开启偏向锁的情况下
打印的数据如下(由于Java15之后偏向锁废弃,因此打开偏向锁打印会警告)
17:15:17 [main] c.MyClass03 - 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000101
最后为101,其他都为0,验证了上述第一条。
可能你又要问了,我这也没使用synchronized关键字呀,那不也应该是无锁么?怎么会是偏向锁呢?
仔细看一下偏向锁的组成,对照输出结果红色划线位置,你会发现占用 thread 和 epoch 的 位置的均为0,说明当前偏向锁并没有偏向任何线程。此时这个偏向锁正处于可偏向状态,准备好进行偏向了!你也可以理解为此时的偏向锁是一个特殊状态的无锁。
关闭偏向锁的情况下
打印的数据如下
17:18:32 [main] c.MyClass03 - 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001
最后为001,其它都是0,验证了上述第二条。
接下来验证加锁的情况,代码如下:
private static Object object = new Object();
public synchronized static void main(String[] args){
new Thread(()->{
log.info("{}", "synchronized前");
log.info("{}", toSimplePrintable(object));
synchronized (object){
log.info("{}", "synchronized中");
log.info("{}", toSimplePrintable(object));
}
log.info("{}", "synchronized后");
log.info("{}", toSimplePrintable(object));
},"t1").start();
}
开启偏向锁的情况,打印数据如下
17:24:05 [t1] c.MyClass03 - synchronized前
17:24:05 [t1] c.MyClass03 - 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000101
17:24:05 [t1] c.MyClass03 - synchronized中
17:24:05 [t1] c.MyClass03 - 00000000 00000000 00000000 00000001 00001110 00000111 01001000 00000101
17:24:05 [t1] c.MyClass03 - synchronized后
17:24:05 [t1] c.MyClass03 - 00000000 00000000 00000000 00000001 00001110 00000111 01001000 00000101
使用了偏向锁,并记录了线程的值(101前面的一串数字),但是处于偏向锁的对象解锁后,线程id仍存储于对象头中。
关闭偏向锁的情况,打印数据如下
17:28:24 [t1] c.MyClass03 - synchronized前
17:28:24 [t1] c.MyClass03 - 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001
17:28:24 [t1] c.MyClass03 - synchronized中
17:28:24 [t1] c.MyClass03 - 00000000 00000000 00000000 00000001 01110000 00100100 10101001 01100000
17:28:24 [t1] c.MyClass03 - synchronized后
17:28:24 [t1] c.MyClass03 - 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001
使用轻量锁(最后为000),并且记录了占中存储的锁信息地址(000前面一串数字),同步块结束后恢复到原先状态(因为没有使用hashcode,所以hashcode值为0)。
偏向锁撤销
在真正讲解偏向撤销之前,需要和大家明确一个概念——偏向锁撤销和偏向锁释放是两码事。
•撤销:笼统的说就是多个线程竞争导致不能再使用偏向模式的时候,主要是告知这个锁对象不能再用偏向模式
•释放:和你的常规理解一样,对应的就是 synchronized 方法的退出或 synchronized 块的结束
何为偏向撤销?
从偏向状态撤回原有的状态,也就是将 MarkWord 的第 3 位(是否偏向撤销)的值,从 1 变回 0
如果只是一个线程获取锁,再加上「偏心」的机制,是没有理由撤销偏向的,所以偏向的撤销只能发生在有竞争的情况下
撤销-hashcode调用
调用了对象的hashcode会导致偏向锁被撤销:
•轻量级锁会在锁记录中记录hashcode
•重量级锁会在Monitor中记录hashcode
测试代码如下
private static Object object = new Object();
public synchronized static void main(String[] args){
object.hashCode();//调用hashcode
new Thread(()->{
log.info("{}", "synchronized前");
log.info("{}", toSimplePrintable(object));
synchronized (object){
log.info("{}", "synchronized中");
log.info("{}", toSimplePrintable(object));
}
log.info("{}", "synchronized后");
log.info("{}", toSimplePrintable(object));
},"t1").start();
}
打印如下:
17:36:05 [t1] c.MyClass03 - synchronized前
17:36:06 [t1] c.MyClass03 - 00000000 00000000 00000000 01011111 00100001 00001000 10110101 00000001
17:36:06 [t1] c.MyClass03 - synchronized中
17:36:06 [t1] c.MyClass03 - 00000000 00000000 00000000 00000001 01101110 00010011 11101001 01100000
17:36:06 [t1] c.MyClass03 - synchronized后
17:36:06 [t1] c.MyClass03 - 00000000 00000000 00000000 01011111 00100001 00001000 10110101 00000001
撤销-其它线程使用对象
当有其它线程使用偏向锁对象时,会将偏向锁升级为轻量级锁。
测试代码如下
private static void test2() {
Thread t1 = new Thread(() -> {
synchronized (object) {
log.info("{}", toSimplePrintable(object));
}
synchronized (MyClass03.class) {
MyClass03.class.notify();//t1执行完之后才通知t2执行
}
}, "t1");
t1.start();
Thread t2 = new Thread(() -> {
synchronized (MyClass03.class) {
try {
MyClass03.class.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
log.info("{}", toSimplePrintable(object));
synchronized (object) {
log.info("{}", toSimplePrintable(object));
}
log.info("{}", toSimplePrintable(object));
}, "t2");
t2.start();
}
打印数据如下
17:51:38 [t1] c.MyClass03 - 00000000 00000000 00000000 00000001 01000111 00000000 11101000 00000101
17:51:38 [t2] c.MyClass03 - 00000000 00000000 00000000 00000001 01000111 00000000 11101000 00000101
17:51:38 [t2] c.MyClass03 - 00000000 00000000 00000000 00000001 01111000 00100000 01101001 01010000
17:51:38 [t2] c.MyClass03 - 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001
可以看到线程t1是使用偏向锁,线程t2使用锁之前是一样的,但是一旦使用了锁,便升级为轻量级锁,执行完同步代码之后,恢复成撤销偏向锁的状态。
撤销-调用wait/notify
代码如下
private static void test3(){
Thread t1 = new Thread(() -> {
log.info("{}", toSimplePrintable(object));
synchronized (object) {
log.info("{}", toSimplePrintable(object));
try {
object.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
log.info("{}", toSimplePrintable(object));
}
}, "t1");
t1.start();
new Thread(() -> {
try {
Thread.sleep(6000);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (object) {
log.debug("notify");
object.notify();
}
}, "t2").start();
}
打印数据如下
17:57:57 [t1] c.MyClass03 - 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000101
17:57:57 [t1] c.MyClass03 - 00000000 00000000 00000000 00000001 00001111 00001100 11010000 00000101
17:58:02 [t2] c.MyClass03 - notify
17:58:02 [t1] c.MyClass03 - 00000000 00000000 01100000 00000000 00000011 11000001 10000010 01110010
调用wait和notify得是用Monitor,所以会从偏向锁升级为重量级锁。
批量重偏向
如果对象虽然被多个线程访问,但没有竞争,这是偏向了线程t1的对象仍然有机会重新偏向t2,重偏向会重置对象的Thread ID。
当撤销偏向锁阈值超过20次后,JVM会这样觉得,我是不是偏向错了呢,于是会在给这些对象加锁时重新偏向至加锁线程。
代码如下
public static class Dog{}
private static void test4() {
Vector<Dog> list = new Vector<>();
Thread t1 = new Thread(() -> {
for (int i = 0; i < 30; i++) {
Dog d = new Dog();
list.add(d);
synchronized (d) {
log.info("{}", i+"\t"+toSimplePrintable(d));
}
}
synchronized (list) {
list.notify();
}
}, "t1");
t1.start();
Thread t2 = new Thread(() -> {
synchronized (list) {
try {
list.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
log.debug("===============> ");
for (int i = 0; i < 30; i++) {
Dog d = list.get(i);
log.info("{}", i+"\t"+toSimplePrintable(d));
synchronized (d) {
log.info("{}", i+"\t"+toSimplePrintable(d));
}
log.info("{}", i+"\t"+toSimplePrintable(d));
}
}, "t2");
t2.start();
}
打印如下
图12
另外我在测试的是否发现一个线程,当对象是普通类(如Dog)时,重偏向的阈值就是20,也就是第21次开启了偏向锁,但是如果把普通类替换成Object时,重偏向的阈值就是9,也就是第10次开启了偏向锁并重偏向(如图13),这是怎么回事儿,有了解的同学可以评论交流下。
图13
批量撤销
当撤销偏向锁阈值超过40次后,JVM会这样觉得,自己确实偏向错了,根本不该偏向,于是整个类的所有对象都会变为不可偏向的,新建的对象也是不可偏向的。
代码如下
static Thread t1, t2, t3;
private static void test6() throws InterruptedException {
Vector<Dog> list = new Vector<>();
int loopNumber = 40;
t1 = new Thread(() -> {
for (int i = 0; i < loopNumber; i++) {
Dog d = new Dog();
list.add(d);
synchronized (d) {
log.info("{}", i + "\t" + toSimplePrintable(d));
}
}
LockSupport.unpark(t2);
}, "t1");
t1.start();
t2 = new Thread(() -> {
LockSupport.park();
log.debug("===============> ");
for (int i = 0; i < loopNumber; i++) {
Dog d = list.get(i);
log.info("{}", i + "\t" + toSimplePrintable(d));
synchronized (d) {
log.info("{}", i + "\t" + toSimplePrintable(d));
}
log.info("{}", i + "\t" + toSimplePrintable(d));
}
LockSupport.unpark(t3);
}, "t2");
t2.start();
t3 = new Thread(() -> {
LockSupport.park();
log.debug("===============> ");
for (int i = 0; i < loopNumber; i++) {
Dog d = list.get(i);
log.info("{}", i + "\t" + toSimplePrintable(d));
synchronized (d) {
log.info("{}", i + "\t" + toSimplePrintable(d));
}
log.info("{}", i + "\t" + toSimplePrintable(d));
}
}, "t3");
t3.start();
t3.join();
log.info("{}", toSimplePrintable(new Dog()));
}
打印如下
图14