阿华代码，不是逆风，就是我疯，你们的点赞收藏是我前进最大的动力！！希望本文内容能够帮助到你！
目录
一：join等待线程结束
1：知识回顾
2：join的功能就是“阻塞等待”
3：谁调用谁等待
4：join和“优先级”区分
二：多线程运行计算
1：情景引入
2：多线程提升进程的运行效率
（1）代码分析
3：串行执行
三：获取线程的引用
1：Thread.currentThread()：
2：创建线程方式影响this引用
3：代码举例如下
四：线程的状态
0：.getState()
1： NEW
2：TERMINATED
3：RUNNABLE
4：TIME_WAITING
5：WAITING
6：BLOCK
引入：通过上一篇文章的学习，我们知道可以通过用Thred的sleep方法，让main函数这个线程进行沉睡，进而达到，让其它线程先执行完毕，main函数在执行这种目的。但是如果不清楚其他线程何时结束，就不能使用sleep方法了
一：join等待线程结束
1：知识回顾
（1）多线程的调度是无序的（随机调度，抢占式执行）
（2）可以通过操作系统提供的一系列api来控制线程的执行顺序
2：join的功能就是“阻塞等待”
如果t1这个线程还在运行，main函数就必须等着，这就是“阻塞等待”。（可以理解成插队，我join到你前面了，一定是我先买到票走人）（阅读以下代码加深理解）
3：谁调用谁等待
因为实在main函数中，t1join进去的，所以main函数等待。如果现在有t1，t2，两个线程都join了呢？——t1 ， t2 并发执行，随机调度，两者都执行完毕了，main函数才能执行
4：join和“优先级”区分
join不是确定“执行顺序”而是确定“结束顺序”，本质是让调用操作系统的api进行控制，让main函数放弃去“调度器”中调度。
package thread;/*** Created with IntelliJ IDEA.* Description:* User: Hua YY* Date: 2024-09-20* Time: 20:34*/
public class ThreadDemon14 {public static void main(String[] args) throws InterruptedException {Thread t1 = new Thread(()->{for (int i = 0; i < 5; i++) {System.out.println("t1线程正在运行");try {Thread.sleep(500);} catch (InterruptedException e) {throw new RuntimeException(e);}}});t1.start();t1.join();System.out.println("这里是main函数线程，我需要等待t1线程执行完毕，才能进行打印");}
}
二：多线程运行计算
1：情景引入
问题：我们用单线程和多线程去计算前1_0000_0000个数字之和，看两者速度差多少
2：多线程提升进程的运行效率
（1）代码分析
下面第一个代码——兵分三路：①main，②算1~5000_0000 ，③算5000_0001~1_0000_0000。本质上来说是 （并发执行=并行+并发） ②③在不同的核心上（并行） ，②③同时运行（并发）
不懂得可以看我前面写过的文章哦！有举例子。
package thread;/*** Created with IntelliJ IDEA.* Description:* User: Hua YY* Date: 2024-09-19* Time: 14:13*/
public class ThreadDemon15 {private static long result = 0;public static void main(String[] args) throws InterruptedException {//用多线程去计算前多少个数字之和Thread thread = new Thread(()->{long tem = 0;for (long i = 0; i < 5000_0000L; i++) {tem += i ;}result += tem ;});Thread thread2 = new Thread(()->{//thread.join();//又变成了串行执行了，并非并发执行long tem = 0;for (long i = 5000_0001 ; i < 1_0000_0000L ; i++) {tem += i;}result += tem;});thread.start();//创建一个新的线程，新的线程跟之前的线程是"并发执行"的关系thread2.start();long beg = System.currentTimeMillis();//记录开始时间//main函数线程阻塞，等待thread线程运行thread.join();thread2.join();//确保thread进程执行完毕在执行main函数long end = System.currentTimeMillis();//记录结束时间System.out.println("双线程的计算结果是：" + result);System.out.println("双线程用到的时间是:" + (end - beg) );}
}
package thread;/*** Created with IntelliJ IDEA.* Description:* User: Hua YY* Date: 2024-09-20* Time: 21:03*/
public class ThreadDemon15_2 {private static long result = 0;public static void main(String[] args) throws InterruptedException {//用多线程去计算前多少个数字之和Thread thread = new Thread(()->{long tem = 0;for (long i = 0; i < 1_0000_0000L; i++) {tem += i ;}result += tem ;});thread.start();//创建一个新的线程，新的线程跟之前的线程是"并发执行"的关系long beg = System.currentTimeMillis();//记录开始时间//main函数线程阻塞，等待thread线程运行thread.join();long end = System.currentTimeMillis();//记录结束时间System.out.println("单线程的计算结果是：" + result);System.out.println("单线程用到的时间是:" + (end - beg) );}
}
3：串行执行
有没有办法让第一个线程结束，在进行第二个线程，最后执行main函数
三：获取线程的引用
1：Thread.currentThread()：
获取到当前线程的引用（Thread引用）
2：创建线程方式影响this引用
如果继承的是Thread类，那么可以用this拿到线程的引用
如果是Runnable或者lambda的方式创建线程，this不能指向Thread对象了，那么此时this就不可以用了，就只能使用Thread.currentThread。
3：代码举例如下
package thread;/*** Created with IntelliJ IDEA.* Description:* User: Hua YY* Date: 2024-09-19* Time: 16:18*/
class MyThread5 extends Thread{@Overridepublic void run() {System.out.println(this.getId() + "," + this.getName());}
}
public class ThreadDemon16 {public static void main(String[] args) throws InterruptedException {/** t1,t2 的先后顺序是不确定的，线程的随机调度*/Thread t1 = new MyThread5();Thread t2 = new MyThread5();t1.start();t2.start();Thread.sleep(1000);System.out.println(t1.getId() + t1.getName());System.out.println(t2.getId() + t2.getName());}}
package thread;/*** Created with IntelliJ IDEA.* Description:* User: Hua YY* Date: 2024-09-19* Time: 16:27*/
public class ThreadDemon17 {/** 使用lambda表达式和Runnable接口写法，就不能用this了*lambda中没有指向任何对象，this没法用* Runnable写法则是this指向的是Runnable* 所以只能用.currentThread这个方法来获取当前*/public static void main(String[] args) {Thread t1 = new Thread(()->{Thread t = Thread.currentThread();System.out.println(t.getId()+t.getName());});Thread t2 = new Thread(()->{Thread t = Thread.currentThread();System.out.println(t.getId()+t.getName());});t1.start();t2.start();}}
四：线程的状态
通过之前的学习，我们知道线程有就绪和阻塞两种状态。下面我们进行更深入的学习
0：.getState()
获取线程的状态
1： NEW
创建了Thread对象，但是还没有调用start方法，线程还没有运行起来
2：TERMINATED
terminated终止状态，一个线程已经执行完毕，但是Thread对象还存在，
3：RUNNABLE
runnable状态，线程正在cpu上运行，或者准备就绪，随时可以上cpu运行
4：TIME_WAITING
time_waiting状态， 多为sleep和join引起的带有一定时间的阻塞等待
5：WAITING
waiting状态，（线程死等），多为wait和join引起
6：BLOCK
block状态，由锁竞争引起的阻塞
/*** Created with IntelliJ IDEA.* Description:* User: Hua YY* Date: 2024-09-19* Time: 16:58*/
public class ThreadDemon18 {public static void main(String[] args) throws InterruptedException {Thread t1 = new Thread(()->{for (int i = 0; i < 3; i++) {System.out.println("线程正在运行");try {Thread.sleep(5000);} catch (InterruptedException e) {throw new RuntimeException(e);}}});System.out.println("t1为NEW状态："+t1.getState());t1.start();//开始执行线程System.out.println("t1是RUNNABLE状态" + t1.getState());t1.join();//main等待t1线程执行完毕 //想要获取WAITING状态把这一行屏蔽掉Thread.sleep(500);//这里是确保让下一句不要那么快执行，正好让 Thread在sleep（1000）的期间获取状态System.out.println("t1是TERMINATED状态"+t1.getState());}
}
