javaEE - 1（9000字详解多线程）

一：认识线程

1.1 线程的概念

线程是操作系统中执行的最小单位，它是进程中的一个实体。一个进程可以包含多个线程，并且这些线程共享进程的资源，如内存、文件句柄等，但每个线程有自己的独立执行流程和栈空间。

线程在操作系统的调度和执行过程中担任重要角色，一个线程就是一个 “执行流”. 每个线程之间都可以按照顺序执行自己的代码. 它可以独立执行特定任务，也可以与其他线程通过同步机制进行协作。通常，一个进程中的多个线程可以并发执行，共享相同的上下文和资源，从而提高系统的并发处理和资源利用率。

1.2 并行和并发

并发和并行是计算机领域中两个常用的概念。

并发指的是在同一时刻只能执行一个任务，但是通过快速切换和时间片轮转等技术，可以让多个任务交替执行，给人一种同时进行的感觉。在并发的情况下，多个任务之间可能是交替执行的。

并行则指的是多个任务在同一时刻同时执行，每个任务拥有自己的执行资源，比如独立的 CPU 核心。在并行的情况下，多个任务可以同时进行，每个任务都在独立的执行路径上进行处理。

简单来说，如果多个任务交替执行，就是并发；如果多个任务同时执行，就是并行。

但是因为并行和并发难以感知，所以我们把并行和并发这两个概念统称为并发

1.3 为啥要有线程

首先, “并发编程” 成为 “刚需”.

单核 CPU 的发展遇到了瓶颈. 要想提高算力, 就需要多核 CPU. 而并发编程能更充分利用多核 CPU资源.
有些任务场景需要 “等待 IO”, 为了让等待 IO 的时间能够去做一些其他的工作, 也需要用到并发编程.

其次, 虽然多进程也能实现并发编程, 但是线程比进程更轻量.

创建线程比创建进程更快.
销毁线程比销毁进程更快.
调度线程比调度进程更快.

最后, 线程虽然比进程轻量, 但是人们还不满足, 于是又有了 “线程池”(ThreadPool) 和 “协程”(Coroutine)，关于线程池我们后面再介绍.

1.4进程和线程的区别

进程是包含线程的. 每个进程至少有一个线程存在，即主线程。
进程和进程之间不共享内存空间. 同一个进程的线程之间共享同一个内存空间.
进程是系统分配资源的最小单位，线程是系统调度的最小单位。

在这里插入图片描述
线程是操作系统中的概念. 操作系统内核实现了线程这样的机制, 并且对用户层提供了一些 API 供用户使用(例如 Linux 的 pthread 库).

Java 标准库中 Thread 类可以视为是对操作系统提供的 API 进行了进一步的抽象和封装.

二：线程操作

2.1创建线程

2.1.1 方法1 继承 Thread 类

继承 Thread 来创建一个线程类.

class MyThread extends Thread {@Overridepublic void run() {System.out.println("这里是线程运行的代码");}
}

注意：run方法中写的是这个线程要执行的任务，一个线程在调用了start()方法之后，才算是真正创建了。

创建 MyThread 类的实例

MyThread t = new MyThread();

调用 start 方法启动线程

t.start(); // 线程开始运行

2.2.2 方法2 实现 Runnable 接口

实现 Runnable 接口

class MyRunnable implements Runnable {@Overridepublic void run() {System.out.println("这里是线程运行的代码");}
}

创建 Thread 类实例, 调用 Thread 的构造方法时将 Runnable 对象作为 target 参数.

Thread t = new Thread(new MyRunnable());

调用 start 方法

t.start(); // 线程开始运行

2.2.3两种方法的区别

这两种写法有一些区别：

继承 Thread 类：当我们继承 Thread 类并重写 run() 方法时，this 关键字表示的是当前线程对象的引用，即 new 出来的线程对象本身。我们可以直接调用该对象的方法，比如 this.sleep()。
实现 Runnable 接口：当我们实现 Runnable 接口并创建了一个 Thread 对象来运行该 Runnable 对象时，this 关键字表示的是实现了 Runnable 接口的类的实例，即 MyRunnable 的引用。我们不能直接调用 this.sleep()，而是要使用 Thread.currentThread().sleep()。

总体上说，两种写法都可以创建线程并实现线程的运行逻辑，不同之处在于 this 表示的对象引用不同。

2.2.4其他变形

匿名内部类创建 Thread 子类对象

// 使用匿名类创建 Thread 子类对象
Thread t1 = new Thread() {@Overridepublic void run() {System.out.println("使用匿名类创建 Thread 子类对象");}
};

匿名内部类创建 Runnable 子类对象

// 使用匿名类创建 Runnable 子类对象
Thread t2 = new Thread(new Runnable() {@Overridepublic void run() {System.out.println("使用匿名类创建 Runnable 子类对象");}
});

lambda 表达式创建 Runnable 子类对象

// 使用 lambda 表达式创建 Runnable 子类对象
Thread t3 = new Thread(() -> System.out.println("使用匿名类创建 Thread 子类对象"));
Thread t4 = new Thread(() -> {System.out.println("使用匿名类创建 Thread 子类对象");
});

通过这几种方法就可以创建一个线程了，需要注意的是，一个线程在调用了start()方法之后，才算是真正创建了。调用start()方法会导致线程进入就绪状态，并且系统会为该线程分配执行资源，使得它可以开始执行run()方法中的代码。

只有调用start()方法才会创建一个新的线程，run()方法只是分配了这个线程的任务是什么，不会创建新的线程。所以，当我们使用多线程编程时，要确保通过调用start()方法来启动线程，以保证线程的正确创建和执行。

三：Thread 类及常见方法

Thread 类是 JVM 用来管理线程的一个类，换句话说，每个线程都有一个唯一的 Thread 对象与之关联。

2.1Thread 的常见构造方法

方法	说明
Thread()	创建线程对象
Thread(Runnable target)	使用 Runnable 对象创建线程对象
Thread(String name)	创建线程对象，并命名
Thread(Runnable target, String name)	使用 Runnable 对象创建线程对象，并命名
Thread(ThreadGroup group, Runnable target)	线程可以被用来分组管理，分好的组即为线程组，这个目前我们了解即可

Thread t1 = new Thread();
Thread t2 = new Thread(new MyRunnable());
Thread t3 = new Thread("这是我的名字");
Thread t4 = new Thread(new MyRunnable(), "这是我的名字");

2.2 Thread 的几个常见属性

属性	获取方法
ID	getId()
名称	getName()
状态	getState()
优先级	getPriority()
是否后台线程	isDaemon()
是否存活	isAlive()
是否被中断	isInterrupted()

ID 是线程的唯一标识，不同线程不会重复
名称是各种调试工具用到
状态表示线程当前所处的一个情况，下面我们会进一步说明
优先级高的线程理论上来说更容易被调度到
关于后台线程，需要记住一点：JVM会在一个进程的所有非后台线程结束后，才会结束运行。
是否存活，即简单的理解，为 run 方法是否运行结束了

2.3 线程中断问题

线程的中断问题，下面我们进一步说明：

interrupt()、interrupted() 和 isInterrupted() 方法是 Java 中用于线程中断的相关方法，它们有着不同的功能和用法。下面我将逐一解释它们的区别，并提供相应的代码示例。

interrupt() 方法：
interrupt() 方法是用于中断线程的方法。它并不会真正地中断线程，而是给线程设置一个中断标志，表示线程被请求中断。具体来说，当调用线程的 interrupt() 方法时，如果线程处于阻塞状态（如 sleep、wait、join 等方法），就会抛出 InterruptedException 异常并清除中断状态，接着结束睡眠，如果线程未处于阻塞状态，仅仅是设置中断标志，并不是真正的中断线程。线程的中断由线程决定，线程可以通过检查中断标志来决定是否中断自己的执行。

Thread 内部包含了一个 boolean 类型的变量作为线程是否被中断的标记：
在这里插入图片描述

以下是一个示例代码，演示了如何使用 interrupt() 方法中断线程：

public class MyThread extends Thread {@Overridepublic void run() {while (!Thread.currentThread().isInterrupted()) {// 线程任务逻辑// ...}}
}public static void main(String[] args) {MyThread thread = new MyThread();thread.start();// 等待一段时间后中断线程try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}thread.interrupt();
}

注意：当sleep被唤醒之后，sleep会自动把 isInterrupted()标志位给清空（true - > false）
在这里插入图片描述
注意：异常的抛出会清除线程的中断标志位，但并不会立即停止线程的执行。它只会在线程的指定时间段内抛出异常，告诉线程当前处于中断状态，然后线程有机会从阻塞状态恢复，并在异常被捕获之后继续执行。

这种设计的目的是为了给开发者一个处理线程中断的机会。当线程被中断后，开发者可以根据具体业务需求来决定如何处理中断，因此，当线程被InterruptedException异常唤醒时，isInterrupted()的返回结果会变为false, 要不要结束线程取决于 catch 中代码的写法. 可以选择
忽略这个异常, 也可以跳出循环结束线程

interrupted() 方法：
interrupted() 方法是一个静态方法，用于判断当前线程是否被中断，并返回中断状态。而且在判断中断状态后，还会自动清除中断标志。如果线程在判断中断状态时没有被中断，则返回 false；如果线程在判断中断状态时被中断，则返回 true。

以下是一个示例代码，演示了如何使用 interrupted() 方法判断当前线程是否被中断：

public class ThreadDemo {private static class MyRunnable implements Runnable {@Overridepublic void run() {for (int i = 0; i < 10; i++) {System.out.println(Thread.interrupted());}}}public static void main(String[] args) throws InterruptedException {MyRunnable target = new MyRunnable();Thread thread = new Thread(target, "李四");thread.start();thread.interrupt();}
}

true // 只有一开始是 true，后边都是 false，因为标志位被清
false
false
false
false
false
false
false
false
false

注意：interrupted() 方法会清除中断状态，即使线程未被中断。

isInterrupted() 方法：

isInterrupted() 方法是一个Java中的线程方法，用于检查当前线程是否被中断。它返回一个boolean值，表示线程是否被中断。

当线程被中断时，isInterrupted() 方法会返回true。但是需要注意的是，调用isInterrupted() 方法并不会清除线程的中断状态。

下面是一个示例代码，演示如何使用isInterrupted() 方法：

public class ThreadDemo {private static class MyRunnable implements Runnable {@Overridepublic void run() {for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().isInterrupted());}}}public static void main(String[] args) throws InterruptedException {MyRunnable target = new MyRunnable();Thread thread = new Thread(target, "李四");thread.start();thread.interrupt();}
}

true // 全部是 true，因为标志位没有被清
true
true
true
true
true
true
true
true
true

下面是这三个方法的总结：

方法	说明
public void interrupt()	中断对象关联的线程，如果线程正在阻塞，则以异常方式通知，否则设置标志位
public static boolean interrupted()	判断当前线程的中断标志位是否设置，调用后清除标志位
public boolean isInterrupted()	判断对象关联的线程的标志位是否设置，调用后不清除标志位

2.4线程启动

之前我们已经看到了如何通过覆写 run 方法创建一个线程对象，但线程对象被创建出来并不意味着线程就开始运行了，调用 start 方法, 才真的在操作系统的底层创建出一个线程.

覆写 run 方法是提供给线程要做的事情的指令清单
线程对象可以认为是把李四、王五叫过来了
而调用 start() 方法，就是喊一声：”行动起来！“，线程才真正独立去执行了。

在这里插入图片描述

2.5 等待一个线程

因为线程是并发执行的，线程的调度是抢占式执行的，所以操作系统对于线程调用的顺序的不知道的，无法判断哪个线程先结束，因此java提供了join（）方法。

在Java中，join()方法是Thread类的一个方法，它允许一个线程等待另一个线程的完成。当一个线程调用另一个线程的join()方法时，调用线程将被阻塞，直到被调用的线程执行完毕。

方法	说明
public void join()	等待线程结束
public void join(long millis)	等待线程结束，最多等 millis 毫秒
public void join(long millis, int nanos)	同理，但可以更高精度

下面是代码示例：

public class JoinExample {public static void main(String[] args) throws InterruptedException {Thread thread = new Thread(() -> {try {// 模拟线程执行耗时的操作Thread.sleep(2000);System.out.println("子线程执行完毕");} catch (InterruptedException e) {e.printStackTrace();}});thread.start(); // 启动子线程thread.join(); // 主线程等待子线程执行完毕System.out.println("主线程继续执行");}
}

在上面的代码中，主线程启动子线程后调用了子线程的join()方法，这样主线程就会等待子线程执行完毕后再继续执行。在子线程中，我们通过模拟一个耗时的操作（线程休眠2秒）来演示子线程的执行过程。当子线程执行完毕后，主线程才会继续执行并输出"主线程继续执行"。

2.6获取当前线程引用

方法	说明
public static Thread currentThread();	返回当前线程对象的引用

这个方法我们非常熟悉了

public class ThreadDemo {public static void main(String[] args) {Thread thread = Thread.currentThread();System.out.println(thread.getName());}
}

2.7 休眠当前线程

也是我们比较熟悉一组方法，有一点要记得，因为线程的调度是不可控的，所以，这个方法只能保证实际休眠时间是大于等于参数设置的休眠时间的。

方法	说明
public static void sleep(long millis) throws InterruptedException	休眠当前线程 millis毫秒
public static void sleep(long millis, int nanos) throws InterruptedException	可以更高精度的休眠

public class ThreadDemo {public static void main(String[] args) throws InterruptedException {System.out.println(System.currentTimeMillis());Thread.sleep(3 * 1000);System.out.println(System.currentTimeMillis());}
}

四：线程的状态

4.2线程的状态

线程的状态是一个枚举类型 Thread.State，我们可以通过这段代码得到线程的状态：

public class ThreadState {public static void main(String[] args) {for (Thread.State state : Thread.State.values()) {System.out.println(state);}}
}

线程在Java中有几种不同的状态，每种状态表示线程在执行过程中的不同阶段或状态。线程的状态主要有以下几种：

新建状态（NEW）：当线程对象被创建时，它处于新建状态。在这个状态下，线程没有被启动，还未开始执行。
可运行状态（RUNNABLE）：线程处于可运行状态意味着线程已经通过调用start()方法启动，可以开始执行了。线程可能正在执行，也可能在等待CPU时间片来执行，或者在等待其他资源。

正在运行（Running）：线程正在执行中。
就绪（Ready）：线程等待CPU调度，具备执行条件，但尚未获得CPU时间片。

阻塞状态（BLOCKED）：线程可能因为等待获取一个排它锁（synchronized关键字）而进入阻塞状态。当其他线程持有锁时，该线程将被阻塞，只有当获取到锁时才能继续执行，BLOCKED 表示等待获取锁
等待状态（WAITING）：线程在等待其他线程的特定操作，例如等待其他线程的通知或等待输入/输出操作完成，WAITING 表示等待其他线程发来通知，WAITING 线程在无限等待唤醒
超时等待状态（TIMED_WAITING）：类似于等待状态，但是可以设置一个超时时间，当超过指定时间后，线程将自动恢复到可运行状态， TIMED_WAITING 表示线程在等待唤醒，等待其他线程发来通知，但设置了时限。
终止状态（TERMINATED）：线程已经完成执行，或者因为异常而终止。

线程状态之间可以相互转换，而且转换的过程是由Java的线程调度器负责控制的。

下面是对线程状态的比喻：

NEW: 安排了工作, 还未开始行动
RUNNABLE: 可工作的. 又可以分成正在工作中和即将开始工作.
BLOCKED: 这几个都表示排队等着其他事情
WAITING: 这几个都表示排队等着其他事情
TIMED_WAITING: 这几个都表示排队等着其他事情
TERMINATED: 工作完成了.

在这里插入图片描述
下面是各个状态的详细关系图：

在这里插入图片描述
所以，之前我们学过的 isAlive() 方法，可以认为是处于不是 NEW 和 TERMINATED 的状态都是活着的。

4.2 yield（）

在Java中，yield()方法用于暂停当前正在执行的线程，并允许其他线程运行。它是线程调度器的一部分，用于实现线程间的合作和协调。

yield()方法的作用是提醒调度器当前线程可以放弃cpu控制权，但是它不保证CPU资源一定会让给其他线程，只是将当前线程的状态更改为就绪状态，然后再次与同等或更高优先级的线程竞争CPU资源。

下面是yield()方法的一般语法：

Thread.yield();

以下几点要注意：

yield()方法只能在线程内部调用，不能在静态方法中使用。
yield()方法不会释放锁，即使线程调用了yield()方法，它仍然持有当前获取的锁。
当线程调用yield()方法后，它可能会立即重新获得执行权，因此yield()方法不能用来实现线程的顺序执行。

下面是一个简单的示例代码，演示了yield()方法的使用：

Thread t1 = new Thread(new Runnable() {@Overridepublic void run() {while (true) {System.out.println("张三");// 先注释掉, 再放开// Thread.yield();}}
}, "t1");
t1.start();
Thread t2 = new Thread(new Runnable() {@Overridepublic void run() {while (true) {System.out.println("李四");}}
}, "t2");
t2.start();