线程学习(2)线程创建,等待,安全,synchronized
"i need your breath"
作者：Mylvzi
文章主要内容：线程学习(2)
前情回顾：
在上一篇博客中介绍到了进程与线程的区别，以及初步了解如何在Java实现多线程编程，通过内置的Thread类来实现多线程，充分利用多核cpu资源，要充分认识到每一个线程都是一个独立的"执行流"，本篇文章继续讲解和Thread有关的一些操作
一.Thread类的创建方式
1.继承Thread 重写run
//创建一个类 继承于Thread类
class MyThread extends Thread {
@Override
public void run() {
// 线程的入口 告诉线程要执行哪些逻辑
System.out.println("hello thread");
try {
// 休眠1s
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
public class Test {
public static void main(String[] args) throws InterruptedException {
// 首先要实例化出一个Thread类
Thread thread = new MyThread();
// start和run都是Thread类的成员
// run只是告诉线程要去执行那些逻辑
// start是真正的调用系统的api，创建出一个线程，再让线程去执行run
thread.start();
// thread.run();
while (true) {
System.out.println("hello main");
// 休眠1s
Thread.sleep(1000);
}
}
}2.实现Runnable 重写run
创建自定义类时让其实现Runnable接口，这样写的原因本质在于Thread类也实现了Runnable接口
class MyThread implements Runnable {
@Override
public void run() {
while(true) {
System.out.println("==");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
}
public class Demo3 {
public static void main(String[] args) throws InterruptedException {
// 使用向上转型 是Java生态中的常见方式
// 先实现一个Runnable接口
Runnable runnable = new MyThread();
Thread thread = new Thread(runnable);
thread.start();
while (true) {
System.out.println("==");
Thread.sleep(1000);
}
}
}说明：
Runnable表示的是一个"可以运行的任务"，这个任务是交给线程执行还是交给其他是体执行，Runnable本身并不关心~
Runnable接口用来表示一个可以在线程中单独执行的任务，一个类只要实现了Runnable接口并且实现他的run方法，那么这个类的实例就能够单独在线程中执行，Runnable接口就像是一个点石成金的"魔法师"，只要被他修饰过，就具有了"可被执行"的属性，这个任务不仅仅可以通过线程来执行，也可以通过线程池和执行器来执行
使用Runnable接口有哪些好处呢?直接继承Thread类不是更简单么?使用Runnable接口最大的好处就是可以"解耦合"，降低代码之间的联系性，代码之间的联系性越高，耦合度就越高；反之亦然，耦合度过高不利于我们之后对代码进行修改~就像你和你最好的哥们一起创业，分钱肯定是不好分的~
上述两种创建Thread类的方式有所不同，第一种是直接通过MyThread类来实例化一个Thread类，第二种是先通过MyThread类先实例化一个Runnable接口，再通过这个接口去实例化一个Thread类。为什么第二种方式耦合度更低呢？原因在于第二种方式自定义类和Thread类之间的联系性降低了，他们之间是通过Runnable接口来联系起来的，以后使用更多线程的时候就都可以通过Runnable这个接口来实现，请看第二种方式创建线程的图解
第一种方式的图解
很明显第二种方式代码之间的耦合性更低
3.继承Thread，重写run，使用匿名内部类
public class Demo4 {
public static void main(String[] args) throws InterruptedException {
// 继承Thread 使用匿名内部类
Thread t = new Thread() {
@Override
public void run() {
while (true) {
System.out.println("hello thread");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
};
t.start();
while (true) {
System.out.println("hello main");
Thread.sleep(1000);
}
}
}4.实现Runnable 重写run，使用匿名内部类
public class Demo11 {
public static void main(String[] args) {
// 实现Runnable 重写run 使用匿名内部类
Runnable runnable = new Runnable() {
@Override
public void run() {
while(true) {
System.out.println("hello thread");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
};
Thread t = new Thread(runnable);
t.start();
}
}5.使用lambda表达式+Runnable接口（推荐方式）
Runnable接口是一个函数式接口，只有一个抽象方法run，所以可以使用lambda表达式来实现
public class Demo12 {
public static void main(String[] args) throws InterruptedException {
// 使用lambda表达式
Runnable runnable = () -> {
while (true) {
System.out.println("Mythread");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
};
Thread thread = new Thread(runnable);
thread.start();
while (true) {
System.out.println("main");
Thread.sleep(1000);
}
}
}使用这种方式创建线程，代码既简洁，又优雅，耦合性也低，推荐大家使用这种方式创建线程
Thread类的其他构造方法
Thread(String name) 创建线程对象，并命名
这个构造方法主要用于给线程命名，方便后续进行调试
// 可以为线程起一个名字作为标识 对线程的执行没有影响 就是单纯的一个"标识" 方便之后调试进行检查区分
Thread t = new Thread(() -> {
while (true) {
System.out.println("hello thread");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
},"这是一个线程名字");Thread(Runnable target, String name) 使用 Runnable 对象创建线程对象，并命名 【了解】Thread(ThreadGroup group, Runnable target) 线程可以被用来分组管理，分好的组即为线程组
二.Thread类的一些属性
1.ID
线程的唯一标识，是Java为每个线程分配的"身份标识"
获取方法
getId()
Thread t = new Thread();
long tid = t.getId();// 返回值是一个长整型
System.out.println("线程ID：" + tid);// 输出线程ID：202.名称name
就是线程的名字，便于后序进行调试
获取方法
getName()
Thread t = new Thread("我是线程");
String tName = t.getName();
System.out.println(tName);// 输出我是线程注意：此方法在源码中是被final修饰的，意味着子类无法重写方法
3.状态 state
进程最常见的两种状态是就绪状态和阻塞状态，线程也有自己的一些属性
// 获取线程的所有状态
for (Thread.State state : Thread.State.values()) {
System.out.print(state+" ");
}
- NEW Thread 对象已经存在 但是还没有通过start方法调用
- RUNNABLE 就绪状态 线程已经在cpu上执行/等在在cpu上执行
- TERMINATED Thread对象还在 但系统内核中的线程不存在
- TIMED_WAITING 阻塞 由于sleep这种固定时间的方式产生的阻塞
- WAITING 阻塞 由于wait这种不固定时间的方式产生的阻塞
- BLOCKED 阻塞 由于锁竞争导致的阻塞
Thread t = new Thread(() -> {
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
});
System.out.println(t.getState());// Thread类存在，但是还没有调用start方法，状态为NEW
t.start();
System.out.println(t.getState());// RUNNABLE
Thread.sleep(3000);
System.out.println(t.getState());// TERMINATED4.优先级priority
获取线程的优先级
获取方法
getPriority
Thread t = new Thread("我是线程");
int tPriority = t.getPriority();
System.out.println(tPriority);说明：其实此方法很"鸡肋"，因为线程的优先级是由cpu的调度器决定的，在我们写代码的过程中很少去关注优先级，一是我们根本就观察不到，二是根本也没这个必要
5.是否是后台线程
线程可以分为两类，前台线程和后台线程，默认情况下是前台线程。后台线程又叫做"守护线程"，就像一场表演的后台工作人员一样，对于后台线程来说，后台线程不结束，不影响整个进程的结束(表演完了，可后台人员还需要处理后事，他们的工作还没结束)，而对于前台线程来说，一个Java程序中，如果还有前台进程没有结束，则整个进程是一定不会结束的
获取方法
isDaemon
// 源码规定 默认是前台线程
/* Whether or not the thread is a daemon thread. */
private boolean daemon = false;
Thread t = new Thread("我是线程");
boolean isDaemon = t.isDaemon();
System.out.println(isDaemon);// 输出false代码验证
public static void main(String[] args) {
Thread t = new Thread(() -> {
while (true) {
System.out.println("hello thread");
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
});
t.start();// 默认是前台线程 持续打印hello thread
}对于这个代码来说，主线程中没有要执行的语句，也就是说他的主线程是在一瞬间就执行完了，但是由于t是前台线程，前台线程不结束整个进程就不会结束，如果将t设置为后台线程呢
public static void main(String[] args) {
Thread t = new Thread(() -> {
while (true) {
System.out.println("hello thread");
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
});
// 在线程开启前将其设置为后台线程
t.setDaemon(true);
t.start();
} 
可以看到什么也没有打印。因为主线程是前台线程，飞快执行完毕之后没有其他的前台线程，整个进程终止，也就是说t线程没来得及执行，整个进程就结束了。也就是说只要一个进程中的所有前台线程结束，就代表整个进程的结束
验证，先让主线程休眠3s，3s之后主线程会立即结束，尽管t线程内部还有语句没有执行，由于前台线程的结束，导致整个进程结束
public static void main(String[] args) throws InterruptedException {
Thread t = new Thread(() -> {
while (true) {
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.println("hello thread");
}
});
// 在线程开启前将其设置为后台线程
t.setDaemon(true);
t.start();
System.out.println("主线程开启");
Thread.sleep(3000);
}
6.是否存活
判断内核线程是否还存活
在Java中我们通过Thread类来创建出一个线程，但实际上Thread类的生命周期要比内核中的线程要长一些，也就是说线程已经不存在了，但是你创建的Thread类仍然存在，使用isAlive判定内核线程是否已经结束
isAlive()
public static void main(String[] args) throws InterruptedException {
// 创建一个线程
Thread t = new Thread(() -> {
System.out.println("线程开始");
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.println("线程结束");
});
// 开启线程
t.start();
System.out.println(t.isAlive());// 输出true
Thread.sleep(3000);
System.out.println(t.isAlive());// 输出false
}线程t内部的方法我们称之为回调方法，当回调方法执行完毕之后，就代表t这个线程的终止，但是Thread类对象的生命周期并未结束
System.out.println(t.isAlive());// 输出false
// 开启线程
t.start();如果在线程开启之前打印，输出false，因为此时t线程还没有被创建
三.线程的中断
终止/打断 interrupt
在Java中要想销毁/中断一个线程的方法是比较唯一的，
就是想办法让run方法尽快执行完毕
那么如何实现呢？这里提供两种方法
1.手动设置标志位，来作为run方法结束的条件
很多线程之所以会持续很久，是因为run方法内部存在循环，结束run方法就是终止循环
// 将标志位设置为类变量
private static boolean isQuit = false;
public static void main(String[] args) throws InterruptedException {
Thread t = new Thread(() -> {
while (!isQuit) {
System.out.println("Thread is working");
}
});
t.start();
// 五秒后改变标志位
Thread.sleep(2000);
isQuit = true;
}通过设置标志位，并在主线程中修改标志位，这样就实现了在5秒之后中断此线程的效果
注意：
1.isQuit不能设置为main方法中的局部变量，因为在lambda表达式中使用的变量必须是被final修饰的常量，如果设置为局部变量，就无法再次更改isQuit，导致无法结束循环。
2.将isQuit设置为"类变量"，lambda表达式此时访问这个成员就不再是变量捕获了，而是内部类访问外部类这个语法了。此时就没有final的限制
上述方法虽然能够结束run方法，但是过于繁琐，且不优雅，需要人为的手动设置标志位，同时，如果在主线程中我们改变了标志位的值，但是此时线程却在sleep，那就只能等到线程再次苏醒才能终止该线程，所以说通过设置标志位的方法来终止线程还有反应不及时的问题
2.使用Thread内部自带的"标志位"
其实在Thread类中，有自带的标志位isInterrupted，默认是false
public static void main(String[] args) throws InterruptedException {
Thread t= new Thread(() -> {
// 先获取当前Thread的实例 在判断其自带的标志位isInterrupted
while (!Thread.currentThread().isInterrupted()) {
while (true) {
System.out.println("Thread is working");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
});
t.start();
Thread.sleep(3000);
// 此方法就是将自带的标志位isInterrupted设置为true
t.interrupt();
}通过t.interrupt()方法将标志位设置为true来终止线程，这种方法的一个优点是即使线程内部处于"阻塞"状态(sleep)，也能够强制将其唤醒，终止run方法，反应更加及时
总结：两种中断线程的方法逻辑都是一样的，即设置合适的标志位，并修改该标志位来终止run方法，从而终止整个线程，但是更加推荐第二种方法
但是上述代码的运行结果是什么呢？请看
异常被抛出且被捕获，但是t线程仍在工作，并没有发生中断，这是为什么呢？通过interrupt方法唤醒线程之后，此时sleep方法会抛出异常，同时自动清除刚才设置的标志位，相当于白白设置标志位了，为什么要这么做呢？是为了让我们有更多的操作空间，在捕获到异常之后，我们可以自由采用以下三种处理方式
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// 1.方式1 不管不顾 让t线程继续运行
e.printStackTrace();
// 2.方式2 使用break直接中断进程
// 3.方式3 捕获到线程之后处理其他工作的代码
// 此处就存放需要解决的其他工作的代码
}四.线程的等待
一个线程等待另一个线程执行结束，再继续执行。线程等待的本质是控制线程结束的顺序
在Java中使用join来实现线程等待效果
主线程中使用join，就是主线程等待另一个线程结束再继续执行主线程的其余代码
public static void main(String[] args) throws InterruptedException {
Thread t= new Thread(() -> {
for (int i = 0; i < 5; i++) {
System.out.println("线程工作中！");
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
});
t.start();
System.out.println("线程开启");
t.join();// 让主线程等待t线程
System.out.println("线程结束");
}
t.join()的工作过程
- 如果t线程还没有结束，就让主线程等待t线程执行结束，再去执行主线程中剩余的代码，此时主线程就是一个"阻塞"状态
- 如果t线程已经结束了，直接返回，不存在"阻塞状态"
在哪个线程中调用join方法就是让哪个线程等待另一个线程
说明：join方法默认是"死等"，即如果被等待的线程没结束，就不会执行其余代码，但这种方式存在一个问题，如果被等待的线程是死循环，那其余代码就永远无法执行，在实际的开发中，我么更推荐"有时间"的等待
此处表示主线程只等待1s，1s之后就会去执行主线程中剩余代码
补充：关于调度开销
当我们使用Thread.sleep方法时，我们通过设置一定的时间让线程处于阻塞状态，结束之后再恢复为就绪状态，由阻塞到就绪其时间一定等于sleep的时间么
long beg = System.currentTimeMillis();
Thread.sleep(1000);// 休眠1s
long end = System.currentTimeMillis();
System.out.println("时间：" + (end - beg) + " ms");// 输出1003 
可见由阻塞到就绪这部分的时间并不等于sleep的时间，原因在于休眠结束之后，线程并不是立马就变为就绪状态，而是需要通过调度器进行调度，而这种调度是需要时间的，这部分由于调度器调度所产生的时间就叫做调度开销
五.线程安全问题
有些代码如果只是一个线程单独去执行，执行结果是完全正确的
但是，同样的代码，如果使用多个线程同时去执行，执行结果就可能产生问题，这种就是"线程安全问题"/"线程不安全"
比如我们要对一个数使其自增1w，如果只使用一个线程来解决，其结果一定正确
public static void main(String[] args) {
// 在主线程中单独执行
int cnt = 0;
for (int i = 0; i < 10000; i++) {
cnt++;
}
System.out.println(cnt);// 输出10000
}如果使用两个线程实现这个目标，则应该是一个线程自增5000次，加起来一共自增1w次
private static int cnt = 0;
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(() -> {
for (int i = 0; i < 5000; i++) {
cnt++;
}
});
Thread t2 = new Thread(() -> {
for (int i = 0; i < 5000; i++) {
cnt++;
}
});
// 线程开启
t1.start();
t2.start();
// 让主线程等待两个线程结束
t1.join();
t2.join();
// 输出打印
System.out.println(cnt);// 输出7351
}
最后的打印结果是一个莫名其妙的数，不是我们想的1w，如果继续重复尝试，发现每次打印的结果还都不相同 ，程序出现bug了，这种问题就是在并发编程中常遇到的线程安全问题
为什么会出现这种问题呢，此时就要深入底层去看下cnt++这个操作是如何实现的
cnt++的实现在底层中分为三步
- load 把数据从内存中 读取到cpu寄存器中
- add 把寄存器中的数据+1
- save 把寄存器中的数据，保存到内存之中
站在cpu的角度，cnt++这个操作分别对应着三条cpu指令，是由这三条指令实现的~
如果使用多线程来执行上述代码，由于线程之间的调度顺序是随机的，就会导致在一些调度顺序下发生错误，下面来看都有哪些可能的调度顺序
可以看出，调度顺序的种类其实是无数种！！！一是调度操作的逻辑顺序，二是每个线程执行多少次我们并不知道，在图中，只有前两种的调度顺序才能达到我们想要的结果，下面以一个反例来验证其他顺序的错误
由于线程调度的随机性，也就说上述调度顺序也是随机的，所以最终产生的结果也是随机的(但是最终的结果一定比1w小，因为只有前两种调度顺序才能实现数字的正确增加)
那一定比5000大么，这也是不一定的，如果在t1自增一次的过程中，t2自增了两次，一共消耗了三次自增，但实际上只自增了一次，如果这种逻辑顺序占多数，就有可能出现<5000的情况
产生线程安全问题的原因
- 操作系统中，线程的调度顺序是随机的(抢占式执行) 罪魁祸首
- 多个线程，针对同一个变量进行修改(上述例子就是)
- 修改操作不是原子的，cnt++这个操作是分三步执行的，不是原子的。什么是原子的呢》比如存在一个cpu指令能同时完成cnt++的三个操作
- 内存可见性问题
- 指令重排序问题
说明：
对于第二种原因，改变一些描述就不是线程安全问题了
- 一个线程，针对同一个变量进行修改 ok
- 多个线程，针对不同的变量进行修改 ok
- 多个线程，针对不同的变量进行读取 ok
通过加锁就能解决上述问题
六.锁 synchronized
1.基本概念
如何给Java的代码进行加锁呢？其中最常用的方法是通过synchronized关键字(最好还是掌握下他的发音和含义)
synchronnized在使用的时候需要搭配{}来使用，进了{}就相当于"加锁"，出了{}就是"解锁",在已经加锁的状态下，如果另一个线程也尝试同样加这个锁，就会发生"锁竞争"/"锁冲突"，后一个线程就会阻塞等待
加锁，我们要明确是给谁加锁，也就是要对具体的对象进行加锁，只有当两个线程针对同一个对象进行加锁，才会发生冲突，针对不同的对象加锁，就不会发生冲突(可以把加锁理解为确立男女朋友关系，一旦确立(加锁)，就不允许其他人再进入了，除非原先的关系破裂(解锁)，不能脚踏两只船~~~)
代码实现:
// 锁竞争的对象
Object locker = new Object();
Thread t1 = new Thread(() -> {
for (int i = 0; i < 5000; i++) {
// 使用synchronized关键字进行加锁
synchronized(locker) {
cnt++;
}
}
});
Thread t2 = new Thread(() -> {
for (int i = 0; i < 5000; i++) {
// 使用synchronized关键字进行加锁
synchronized(locker) {
cnt++;
}
}
});在这个代码中，我们先是创建了一个用于"加锁"的对象locker,接着进行加锁，如何加锁呢？根据上述引发线程安全的2"多个线程，针对同一个变量进行修改"，我们要限制的是两个线程不能同时对同一个变量进行修改，所以应该加锁的操作是"cnt++",使用synchronized(locker){}对其进行加锁
这种情况是我们上述所说的会引发线程安全问题的一种调度顺序，下面看看加锁是如何解决这个问题的
对象存在的意义有且仅有一个，当多个线程针对同一个对象进行加锁的时候，就会发生锁冲突，一个线程拿到锁，就继续执行代码，而另一个线程没拿到锁，就会处于阻塞状态。直到另一个线程释放锁，才能继续执行剩余代码~
这样做实际上是把"并发执行"转换为"串行执行"，这样就避免了操作之间的穿插，导致错误的出现
注意：必须是多个线程针对同一个对象进行加锁，如果是不同的对象就不会发生锁冲突，也就不会出现线程阻塞
// 锁竞争的对象
Object locker = new Object();
Object locker2 = new Object();
Thread t1 = new Thread(() -> {
for (int i = 0; i < 5000; i++) {
synchronized(locker) {
cnt++;
}
}
});
Thread t2 = new Thread(() -> {
for (int i = 0; i < 5000; i++) {
// 此时两个线程针对的是不同的对象进行加锁 不发生锁冲突
synchronized(locker2) {
cnt++;
}
}
});还是那句话，锁的对象是谁不重要，只要锁的是同一个对象就一定会引发锁冲突！！！
2.synchronized对方法进行加锁
除了对对象加锁，synchronized还可以对方法加锁
下面先修改一下我们的代码：
class Counter {
public static int cnt;
// 将cnt++这个操作放到一个方法内部
public void increment() {
cnt++;
}
}
public static void main(String[] args) throws InterruptedException {
Counter counter = new Counter();
Thread t1 = new Thread(() -> {
for (int i = 0; i < 5000; i++) {
counter.increment();
}
});
Thread t2 = new Thread(() -> {
for (int i = 0; i < 5000; i++) {
counter.increment();
}
});
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println(counter.cnt);
}此时继续执行代码，发现结果仍然是随机值，原因在于还是出现了"两个线程同时针对同一个变量进行修改"这样的操作，解决方法就是进行加锁,此时我们可以对increment()这个方法进行加锁
synchronized public void increment() {
cnt++;
}
加锁之后，只能有一个线程拥有increment(),另一个线程想要使用的话只能等前一个线程释放锁之后才能使用
上述对方法加锁的方式还有一个等价方式
public void increment2() {
// 这其实是对"实例方法"进行加锁的
// 实例方法的实现取决于实例化的对象 也就是本质上是对调用这个方法的对象进行加锁
// 让调用方法的对象拥有这个锁
synchronized (this) {
cnt++;
}
}同样的，synchronized还可以对"类方法进行加锁"，对类方法加锁本质上就是对类对象进行加锁
// 类方法
synchronized public static void increment3() {
cnt++;
}
public static void increment4() {
// 这里利用到了反射
synchronized (Counter.class) {
cnt++;
}
}
说明：类对象在一个Java文件中是唯一的，类对象中包含很多信息，比如类的属性，方法，继承关系，实现接口等等，类对象可以通过反射的方式获取
3.对象的"锁属性"是存在于对象头中的
我们知道一旦一个对象被synchronized修饰就代表该对象被上锁了，也就是说synchronized改变了对象的原有属性，而这个决定对象是否被"锁"的属性存在于"对象头"之中
对于一个对象来说，除了其自定义的一些属性，还有一些系统为其分配的属性，这些属性的集合被称为"对象头"，对象头中，就有属性用于表示对象是否被锁，以下是对象数据的组成
4. synchronized的重要特性-可重入性
要了解可重入性，先了解什么是可重入锁，所谓的可重入锁就是指：
一个线程能够对同一个对象连续加锁两次，不会出现死锁，就是可重入。不满足，就是不可重入；
而被synchronized修饰的对象都具有可重入性,再简单来说，可重入性就是指一个线程再持有一个对象的锁之后，还可以再次对该对象加锁，举一个简单的例子
class MyClass {
// 创建两个静态方法
synchronized public static void methodA() {
System.out.println("这是methodA");
methodB();
}
synchronized public static void methodB() {
System.out.println("这是methodB");
}
public static void main(String[] args) {
// 调用类方法 此时synchronized是对类对象进行加锁
MyClass.methodA();
}
}再这个例子中，主线程中我们调用了methodA，因为 methodA是被synchronized修饰的，此时主线程就持有了MyClass类对象类的锁，紧接着进入methodB,因为methodB也是synchronized修饰的，所以即便在methodA内部调用methodB，主线程也会再次获取MyClass类对象类的锁，会直接获取成功
今天线程的学习就到这里，敬请期待后续章节