✏️作者：银河罐头
📋系列专栏：JavaEE
🌲“种一棵树最好的时间是十年前，其次是现在”
目录
- 1.认识线程
- 1.1概念
- 1.2多线程程序
- 1.3创建线程
- 2.Thread类及常见方法
- 2.1Thread 的常见构造方法
- 2.2 Thread 的几个常见属性
- 2.3中断一个线程
- 2.4等待一个线程-join()
1.认识线程
1.1概念
进程是操作系统资源分配的基本单位，线程是操作系统调度执行的基本单位
引入进程这个概念，最主要的目的是为了解决"并发编程"这样的问题，这是因为CPU进入了多核心时代，要想进一步的提升程序的执行速度，就需要充分的利用CPU的多核资源。
其实，多进程编程，已经可以解决并发编程的问题了，已经可以利用起来CPU的多核资源了。
但是，进程太重了。(这里的"重"指的是消耗资源多+速度慢)
进程"重"就"重"在了资源分配/回收
创建一个进程，开销比较大；销毁一个进程，开销也比较大；调度一个进程，开销还比较大。
线程也叫做"轻量型进程"。解决并发编程的问题的前提下，让创建，销毁，调度的速度更快一些。
线程为什么更"轻"，因为它省去了申请资源和释放资源的操作。
举例:一个工厂加工产品
工厂效益好了，想要提高生产力，有两个方案
方案一：再租一个场地，再买一套生产线和物流线
方案二：在原场地的基础上，只用买一套生产线，场地和物流线可以复用
分析：方案二与方案一相比更节省成本
方案一相当于多进程，方案二相当于多线程
线程和进程的关系，进程包含线程。
一个进程可以包含1个或多个线程，不能没有。
只有第一个线程启动的时候开销是比较大的，后续线程就省事了。
同一个进程的多个线程之间共用同一份资源(主要指的是内存和文件描述符表)。(这里的内存：你线程1new的个对象，线程2，3，4都可以直接使用)(这里的文件描述符表：线程1里打开的文件，线程2，3，4都可以直接使用)
操作系统里实际调度的时候，是以线程为单位进行调度的。
如果每个进程有多个线程，那么每个线程是独立在CPU上进行调度的，线程是操作系统调度执行的基本单位。
每个线程有自己的执行逻辑(执行流)
一个线程也是通过一个PCB进行描述的，也就是说一个进程可能对应1个PCB，也可能对应多个PCB。
之前学过的，PCB里的状态，上下文，优先级，记账信息都是每个线程有自己的，各自记录各自的。
而同一个进程的PCB之间，pid是一样的，内存指针，文件描述符表也是一样的。
进程专门负责资源分配，线程来接管和调度相关的一切内容。
多线程也会带来一些问题：
- 为了提高速度可以增加线程数量，但不是一直增加线程数量，速度能一直提高的，因为CPU核心数量是有限的。线程数目太多，核心数目有限，不少的开销反而浪费在线程调度上了。
系统创建线程，也是要消耗资源的，(虽然比进程轻量，但也不是0)，如果你创建线程太多，会导致资源耗尽，导致别的进程用不了，这里的资源指的是CPU，内存，带宽等。
-
多线程情况下，还可能带来线程安全问题。
在多个执行流访问同一个共享资源的时候可能会有线程安全问题。
线程模型，天然就是资源共享的，多线程争抢同一个资源(同一个变量)非常容易触发。
进程模型，天然是资源隔离的，不容易触发。在进行进程间通信的时候，多个进程访问同一份资源，可能会有问题。
-
如果一个线程抛异常，如果没有处理好，可能使得整个进程崩了，其他线程也就挂了。
chrome浏览器要使用多进程编程模型(每个标签页都是一个进程)，目的是为了防止一个页面挂了使得其他页面也挂了
多线程的编程模型要比多进程的编程模型更加广泛
1.2多线程程序
在Java中如何是实现多线程编程。
Java执行多线程，最核心的类Thread
Thread t = new MyThread();
t.run();//虽然t是父类引用，此处调用的run仍然是子类的方法。(t本质上还是指向子类的对象)
使用Thread类不需要import别的包，Thread类在java.lang包下
还有哪些类类似？String，StringBuffer，StringBuilder
而像ArrayList，HashMap，Scanner，Random这些类都在java.util包下
创建线程是希望线程能够成为一个独立的执行流(执行一段代码)
如何指定？
t.start();
//t创建了一个新的线程，由这个新的线程调用run()
//调用操作系统的API，通过操作系统内核创建新线程的PCB，并且把要执行的指令交给这个PCB，然后这个PCB被调度到CPU上执行的时候，就执行到了线程run方法里的代码
public static void main(String[] args) {
System.out.println("hello world");
//如果只是直接打印hello world，Java进程主要就是有一个线程(调用main方法的线程)，主线程
}
package Thread;
class MyThread extends Thread{
@Override
public void run() {
System.out.println("hello world");
}
}
public class ThreadDemo1 {
public static void main(String[] args) {
Thread t = new MyThread();//不创建线程(说的线程指的是系统内核里的PCB)
t.start();
//通过t.start()，主线程调用t.start(),创建一个新线程，通过这个新线程调用t.run()
//如果run()方法执行完毕，新线程就销毁
}
}
怎样体现出并发编程？
package Thread;
class MyThread extends Thread{
@Override
public void run() {
while(true) {
System.out.println("hello thread");
//为了让这里的打印慢点，方便看，加个sleep，休眠1s
try{
Thread.sleep(1000);
}catch(InterruptedException e){
e.printStackTrace();
}
}
}
}
public class ThreadDemo1 {
public static void main(String[] args) {
Thread t = new MyThread();
t.start();
while(true){
System.out.println("hello main");
try{
Thread.sleep(1000);
}catch (InterruptedException e){
e.printStackTrace();
}
}
}
}
操作系统调度线程的时候，“抢占式执行”，具体哪个线程先上，哪个线程后上，不确定，取决于操作系统调度器具体实现策略。
虽然有优先级，但是在应用程序(代码)层面上无法修改，从应用程序(代码)的角度，看到的效果就好像是线程之间的调度顺序是"随机"的一样。
内核里并非是随机的，但是干预因素太多了，并且应用程序这一层也无法感知到细节，就只能认为是随机的了。(可以通过一些api进行有限度的干预)
- start和run之间的区别：start是真正创建了一个线程(从系统这里创建的)，线程是独立的执行流。
可以使用jdk自带的工具jconsole查看当前的java进程中的所有线程
JDK是Java开发工具包，这里带的工具很多，不只是javac和java
main线程销毁之后，thread-0线程会销毁吗？默认是不会的，守护线程/非守护线程
PCB对应的是线程，一个线程对应一个PCB，一个进程对应多个PCB，如果一个进程里只有一个线程，那就是一个进程对应一个PCB了。
同一个进程里的若干PCB的pid相同，不同进程里的pid不同
PCB只是操作系统书里说的概念，实际上Linux对应结构体名字叫做task_struct
PCB不是简称，它是一个数据结构，体现的是进程/线程是如何实现，如何被描述出来的。
1.3创建线程
- 1.继承Thread，重写run
package Thread;
class MyThread extends Thread{
@Override
public void run() {
while(true) {
System.out.println("hello thread");
try{
Thread.sleep(1000);
}catch(InterruptedException e){
e.printStackTrace();
}
}
}
}
public class ThreadDemo1 {
public static void main(String[] args) {
Thread t = new MyThread();
t.start();
while(true){
System.out.println("hello main");
try{
Thread.sleep(1000);
}catch (InterruptedException e){
e.printStackTrace();
}
}
}
}
- 2.实现Runnable接口
package Thread;
//Runnable作用是描述一个要执行的任务，run方法就是任务的执行细节
class MyRunnable implements Runnable{
@Override
public void run() {
System.out.println("hello thread");
}
}
public class ThreadDemo2 {
public static void main(String[] args) {
Runnable runnable = new MyRunnable();
Thread t = new Thread(runnable);
t.start();
}
}
//解耦合，让线程和线程要执行的任务分离开
//好处是如果未来要改代码，不用多线程，使用多进程，或者线程池，协程...代码改动比较小
- 3.使用匿名内部类，继承Thread
//使用匿名内部类来创建线程
public class ThreadDemo3 {
public static void main(String[] args) {
Thread t = new Thread(){
//1.创建了一个Thread类的子类，(子类没有名字所以才叫匿名)
//2.创建了子类的实例并且让t指向该实例
@Override
public void run() {
System.out.println("hello");
}
};
t.start();
}
}
- 4.使用匿名内部类，实现Runnable
public class ThreadDemo4 {
public static void main(String[] args) {
Thread t = new Thread(new Runnable() {
@Override
public void run() {
System.out.println("hello");
}
});
t.start();
}
}
//这个写法和2本质相同，只不过是把实现Runnable的任务交给匿名内部类的语法
//此处是创建了一个类，实现了Runnable接口，并创建了类的实例，并且传给了Thread的构造方法。
- 5.使用Lambda表达式
public class ThreadDemo5 {
public static void main(String[] args) {
Thread t = new Thread(()->{
System.out.println("hello");
});
t.start();
}
}
//把任务用lambda表达式来描述，直接把lambda传给Thread的构造方法
//lambda就是个匿名函数，就用一次
2.Thread类及常见方法
2.1Thread 的常见构造方法
package Thread;
public class ThreadDemo6 {
public static void main(String[] args) {
Thread t = new Thread(new Runnable() {
@Override
public void run() {
while(true) {
System.out.println("hello");
}
}
},"myThread");
t.start();
//对于主线程来说，执行完t.start()之后，main方法结束，主线程执行完了
//t是代码里的变量名，而myThread是系统里的线程名
}
}
注意这里线程列表中没有主线程，因为主线程执行完了
2.2 Thread 的几个常见属性
| 属性 | 获取方法 |
|---|---|
| ID | getId() |
| 名称 | getName() |
| 状态 | getState() |
| 优先级 | getPriority() |
| 是否后台线程 | isDaemon() |
| 是否存活 | isAlive() |
| 是否被中断 | isInterrupted() |
-
getName()：构造方法里起的名字
-
getState()：线程状态。Java里线程的状态要比操作系统原生的状态更加丰富一些
-
getPriority()：这个可以获取，也可以设置(但设置没什么用)
-
isDaemon()：是否是守护线程(后台线程)。前台线程会阻止进程结束，后台线程不会阻止进程结束
代码里手动创建的线程默认都是前台的，包括main默认也是前台的，其他JVM自带的线程是后台的
也可以手动的使用setDaemon设置成后台线程
-
isAlive()
在真正调用start之前，调用t.isAlive是false，调用t.start之后isAlive就是true。另外如果内核里线程把run执行完了，此时线程销毁PCB随之释放，但是Thread t这个对象还不一定被释放，此时isAlive是false。
isAlive是在判断当前系统里这个线程是否存在。
public static void main(String[] args) {
Thread t = new Thread(new Runnable() {
@Override
public void run() {
System.out.println("hello");
}
},"myThread");
t.start();//t还在，引用不指向这个对象被GC回收的时候，t就不在了
while(true){
try{
Thread.sleep(1000);
System.out.println(t.isAlive());
}catch (InterruptedException e){
e.printStackTrace();
}
}
}
如果t.run还没执行，isAlive是false;
如果t.run正在执行，isAlive是true;
如果t.run执行结束，isAlive是false;
2.3中断一个线程
中断的意思不是让线程立即停止，而是通知线程你该停止了。是否真的停止，取决于线程这里的代码写法。
- 1.使用标志位来控制线程是否要停止
private static boolean flag = true;
public static void main(String[] args) throws InterruptedException {
Thread t = new Thread(()->{
while(flag){
System.out.println("hello thread");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
t.start();
Thread.sleep(3000);
//在主线程里就可以随时通过flag变量的取值，来操作t线程是否结束
flag = false;
}
- 2.使用Thread自带的标志位来进行判断
这种可以唤醒sleep
public static void main(String[] args) throws InterruptedException {
Thread t = new Thread(()->{
while(!Thread.currentThread().isInterrupted()){
//Thread.currentThread()
//这是Thread类的静态方法，通过这个方法可以获取到当前线程，哪个线程调用的这个方法，就可以获取到这个线程的对象引用，相当于this
//是在t.run中被调用的，此处获取到的就是t线程
//isInterrupted()为true表示被终止
System.out.println("hello thread");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
t.start();
Thread.sleep(3000);
t.interrupt();
}
//如果线程在sleep中休眠，此时调用interrupt就会把t线程唤醒，从sleep提前返回。interrupt会触发sleep里的异常InterruptedException，导致sleep提前返回
main调用t.interrupt()，main通知t要被终止
//结果：
hello thread
hello thread
hello thread
//t正常执行
java.lang.InterruptedException: sleep interrupted
at java.lang.Thread.sleep(Native Method)
at Thread.ThreadDemo9.lambda$main$0(ThreadDemo9.java:16)
at java.lang.Thread.run(Thread.java:748)
//调用interrupt触发了异常
hello thread
hello thread
hello thread
hello thread
hello thread
hello thread
.
.
.
//t还在继续执行
interrupt：
把线程内部的标志位(boolean)设置成true,
如果线程在sleep，就会触发异常把sleep唤醒,同时把刚才设置的这个标志位设置成false(清空了标志位)，这就导致当sleep的异常被catch完了之后，循环还要继续执行
//线程t忽略终止请求
public static void main(String[] args) throws InterruptedException {
Thread t = new Thread(()->{
while(!Thread.currentThread().isInterrupted()){
System.out.println("hello thread");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
t.start();
Thread.sleep(3000);
t.interrupt();
}
//线程t立即响应你的终止请求
public static void main(String[] args) throws InterruptedException {
Thread t = new Thread(()->{
while(!Thread.currentThread().isInterrupted()){
System.out.println("hello thread");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
break;
}
}
});
t.start();
Thread.sleep(3000);
t.interrupt();
}
//稍后进行终止
public static void main(String[] args) throws InterruptedException {
Thread t = new Thread(()->{
while(!Thread.currentThread().isInterrupted()){
System.out.println("hello thread");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
try {
Thread.sleep(500);
} catch (InterruptedException ex) {
ex.printStackTrace();
}
break;
}
}
});
t.start();
Thread.sleep(3000);
t.interrupt();
}
如果不是sleep，像wait,join等类似的造成代码"暂停"的方法都会有清除标志位的设定
2.4等待一个线程-join()
有时，我们需要等待一个线程完成它的工作后，才能进行自己的下一步工作。等待线程，控制两个线程的结束顺序。
public static void main(String[] args) {
Thread t = new Thread(()->{
for(int i = 0;i < 3;i++){
System.out.println("hello thread");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
t.start();
System.out.println("join 之前");
//此处的 join 就是让当前的 main 线程来等待 t 线程执行结束(等待 t 的 run 执行完)
try {
t.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("join 之后");
}
执行完t.start()之后main线程和t线程就并发执行。main继续执行遇到join发生阻塞(block),一直阻塞到t线程结束，main线程才从join中恢复回来然后继续向下执行。t线程比main线程先结束
//结果：
join 之前
hello thread
hello thread
hello thread
join 之后
- 如果执行join时，t线程已经结束，会发生什么？
public static void main(String[] args){
Thread t = new Thread(()->{
for(int i = 0;i < 3;i++){
System.out.println("hello thread");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
t.start();
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("join 之前");
try {
t.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("join 之后");
}
//结果：
hello thread
hello thread
hello thread
join 之前
join 之后
如果 join 时 t 线程已经结束，join就不会阻塞，就会立即返回。
![[附源码]计算机毕业设计心理健康系统Springboot程序](https://img-blog.csdnimg.cn/3f74b713a62b420ea3568cfffbe95f35.png)
![[附源码]JAVA毕业设计计算机专业在线学习评估软件-演示录像-（系统+LW）](https://img-blog.csdnimg.cn/0eaef95c4778471c838db57183023c6e.png)
![[附源码]Python计算机毕业设计Django教学辅助系统](https://img-blog.csdnimg.cn/46be7d8dfc534c47bf29a762868b3b6d.png)
