⛺️ 欢迎关注：👍点赞 👂🏽留言 😍收藏 💞 💞 💞
一、背景 -- 进程与线程 🚀
🔥 多线程是提升程序性能非常重要的一种方式，也是Java编程中的一项重要技术。在程序设计中，多线程就是指一个应用程序中有多条并发执行的线索，每条线索都被称作一个线程，它们会交替执行，彼此可以通信。
🥝 1. 进程
🌈 进程（process）是计算机中程序的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。
注意： 虽然进程在程序执行时产生，但进程并不是程序
- 程序是"死"的，进程是"活"的
- 程序是指编译好的二进制文件，它存放在磁盘上，不占用系统资源，是具体的
- 而进程存在于内存中，占用系统资源，是抽象的。当一次程序执行结束时，进程随之消失，进程所用的资源被系统回收
对计算机用户而言，计算机似乎能够同时执行多个进程，如听音乐、玩游戏、语音聊天等，都能在同一台计算机上同时进行。但实际上**，一个单核的CPU同一时刻只能处理一个进程** ，用户之所以认为同时会有多个进程在运行，是因为计算机系统采用了多道程序设计技术
多道程序设计技术（了解）
- 所谓多道程序设计，是指计算机允许多个相互独立的程序同时进入内存,在内存的管理控制之下，相互之间穿插运行。多道程序设计必须有硬件基础作为保障
- 采用多道程序设计的系统，会将CPU的周期划分为长度相同的时间片，在每个CPU时间片内只处理一个进程，也就是说，在多个时间片内，系统会让多个进程分时使用CPU
假如现在内存中只有3个进程------A、B、C，那么CPU时间片的分配情况大致如下
🐸 虽然在同一个时间片中，CPU只能处理一个进程，但CPU划分的时间片是非常微小的，且CPU运行速度极快(1秒可执行约10亿条指令）
- 因此，在宏观上，可以认为计算机能并发执行多个程序、处理多个进程。
🦌 进程对 CPU 的使用权是由操作系统内核分配的，操作系统内核必须知道内存中有多少个进程，并且知道此时正在使用CPU的进程，这就要求内核必须能够区分进程，并可获取进程的相关属性。
🥝 2. 线程
🔥 通过上面可以知道，每个运行的程序都是一个进程，在一个进程中还可以有多个执行单元同时运行，这些执行单元可以看作程序执行的线程（thread)。每一个进程中都至少存在一个线程。
- 例如，当一个Java程序启动时，就会产生一个进程，该进程默认创建一个线程，这个线程会运行main(）方法中的代码。
单线程与多线程
- 如果代码都是按照调用顺序依次往下执行的，没有出现两段程序代码交替运行的效果，这样的程序称作单线程程序
- 如果希望程序中实现多段程序代码交替运行的效果，则需要创建多个线程，即多线程程序
所谓多线程是指一个进程在执行过程中可以产生多个线程，这些线程在运行时是相互独立的，它可以并发执行的。过程如下：
💢 注意：多条线程看起来是同时执行的；其实不然，它们和进程一样，也是由CPU轮流执行的，只不过CPU运行速度很快，因此给人同时执行的感觉。
🥝 3. 进程 VS 线程
3.1 线程的优点
- 创建一个新线程的代价要比创建一个新进程小得多
- 与进程之间的切换相比，线程之间的切换需要操作系统做的工作要少很多
- 线程占用的资源要比进程少很多
- 能充分利用多处理器的可并行数量
- 在等待慢速I/O操作结束的同时，程序可执行其他的计算任务
- 计算密集型应用，为了能在多处理器系统上运行，将计算分解到多个线程中实现
- I/O密集型应用，为了提高性能，将I/O操作重叠。线程可以同时等待不同的I/O操作
3.2 进程与线程的区别
- 进程是系统进行资源分配和调度的一个独立单位 ，线程是程序执行的最小单位
- 进程有自己的内存地址空间，线程只独享指令流执行的必要资源，如：寄存器和栈
- 由于同一进程的各线程间共享内存和文件资源，可以不通过内核进行直接通信
- 线程的创建、切换及终止效率更高
二、线程的创建 🖊
💢****Java 提供了 3 种多线程的创建方式：
- 继承 java.lang 包中的 Thrad 类，重写 Thrad 类的 **run()方法，在run()**方法中实现多线程代码。
- 实现 java.lang.Runnable 接口，在 **run()**方法中实现多线程代码。
- 实现 java.util.concurrent.Callable 接口，重写 **call()**方法，并使用Future接口获取
♻️1. 继承 Thread 类创建多线程
在学习多线程之前，我们先来看一个代码
cpp
class MyThread{
public void run() {
while(true) {
System.out.println("MyThread类的 run（） 方法在运行");
}
}
}
public class thread_create {
public static void main(String[] args) {
MyThread myThread = new MyThread();
myThread.run();
while(true) {
System.out.println("main（）方法在运行");
}
}
}- 显而易见，上面代码输出是个死循环，一直打印 MyThread类的 run（） 方法在运行
⚜️如果我们想让上面代码中的 两个while 循环中的语句能够 并发执行，就需要去实现多线程
- 为此Java 提供了线程类 Thread 。通过继承Thread类 类，并重写Thread类中的 run（)方法，便可实现多线程。
- 在 Thread类 中提供了 start( **)**方法用于启动新线程。
- 新线程启动后，Java虚拟机会自动调用 run(）方法；如果子类重写了run(）方法，便会执行子类中的 run(）方法
修改后的代码如下：
java
class MyThread extends Thread{
public void run() {
while(true) {
System.out.println("MyThread类的 run（） 方法在运行");
}
}
}
public class thread_create {
public static void main(String[] args) {
MyThread myThread = new MyThread();
myThread.start(); // 开启线程
while(true) {
System.out.println("main（）方法在运行");
}
}
}运行如下：
- 由上图可知，两个循环中的语句都输出到控制台，说明实现了多线程。
为了使读者更好地理解单线程程序和多线程程序的执行过程，下面通过下图分析单线程和多线程的区别
从上图可以看出
- 单线程程序在运行时，会按照代码的调用顺序执行
- 而在多线程程序中，main() 方法和 MyThread 类的 run ( ) 方法可以同时运行，互不影响。
♻️2. 实现 Runnable 接口创建多线程
🔥 上面通过继承Thread类实现了多线程，但是这种方式有一定的局限性。因为Java只支持单继承，一个类一旦继承了某个父类，就无法再继承****Thread类
- 例如，Student类继承了Person类,那么Student 类就无法再通过继承Thread类创建线程
🐸 为了克服这种弊端，Thread 类提供了另一个构造方法 ---- Thread(Runnable target)
- 其中参数类型 Runnable 是一个接口，它只有一个 run()方法。
- 当通过Thread(Runnable target) 构造方法创建线程对象时，只需为该方法传递一个实现了Runnable 接口的对象，这样，创建的线程将实现 Runnable 接口中的 run() 方法作为运行代码，而不需要调用 Thread 类中的 **run()**方法。
如下：
java
class MyThread implements Runnable{
public void run() {
while(true) {
System.out.println("MyThread类的 run（） 方法在运行");
}
}
}
public class thread_create {
public static void main(String[] args) {
MyThread myThread = new MyThread(); // 创建实例对象
Thread thread = new Thread(myThread); // 创建线程对象
thread.start(); // 开启线程
while(true) {
System.out.println("main（）方法在运行");
}
}
}运行如下：
- 此时 main() 方法 和 MyThread 类中的 run() 方法都被实现了，说明实现了多线程
♻️3. 实现 Callable 接口创建多线程
🔖 通过 Thread 类和 Runnable 接口实现多线程时，需要重写run(）方法，但是由于run(）方法没有返回值，无法从新线程中获取返回结果。为了解决这个问题，Java 提供了Callable接口来满足这种既能创建新线程又有返回值的需求。
通过实现 Callable接口的方式创建并启动线程的主要步骤如下：
- 创建 Callable 接口的实现类，同时重写Callable 接口的 **call()**方法
- 创建 Callable接口的实现类对象
- 通过线程结果处理类 FutureTask 的有参构造方法封装 Callable接口的实现类对象
- 调用参数为 FutureTask类对象的有参构造方法 Thread()创建Thread线程实例。
- 调用线程实例的 start(）方法启动线程。
cpp
// 定义实现 Callable 的实现类
class MyThread implements Callable<Object> {
// 重写 call 方法
public Object call() throws Exception {
int i = 0;
while (i++ < 3){
System.out.println(Thread.currentThread().getName() + "的方法在运行");
}
return i;
}
}
public class thread_create {
public static void main(String[] args) throws InterruptedException,ExecutionException{
MyThread myThread = new MyThread(); // 创建实例对象
// 使用 FutureTask 封装
FutureTask<Object> ft = new FutureTask<>(myThread);
// 使用 Thread(Runnable target, string name) 构造方法创建线程对象
Thread thread = new Thread(ft, "thread");
thread.start(); // 启动线程
// 通过FutureTask 对象的方法管理返回值
System.out.println(Thread.currentThread().getName() + "的返回结果：" + ft.get());
int i = 0;
while(i++ < 3) {
System.out.println("main（）方法在运行");
}
}
}运行结果如下：
- 上面代码 通过实现 Callable 接口的方式实现了多线程 并且还有返回结果
🌙 Callable 接口 方式实现的多线程是通过 FutureTask 类来封装和管理返回结果的，FutureTask 类的直接父接口是 RunnableFuture ，从名称上可以看出 RunnableFuture 是 Runnable 和Future的结合体。
- FutureTask 类的继承关系如下
由上图 可以知道：FutureTask 的本质是 Runnable 接口 和 Future 接口的实现类。其中 Future 接口用于管理线程返回结果，它共有 5 个方法如下：
|----------------------------------------------------|---------------------------------------------------------------------------------------|
| 方法声明 | 功能描述 |
| boolean cancel (boolean mayInterruptIfRunning) | 用于取消任务。 参数 mayInterruptIfRunning 表示是否允许取消正在执行却没有执行完毕的任务。若参数设为 true，则表示可以取消正在执行的任务 |
| boolean isCancelled () | 判断任务是否被成功取消 |
| boolean isDone () | 判断任务是否已完成 |
| V get() | 用于获取执行结果。注意：这个方法会发生堵塞，一直等到任务执行完毕才返回执行结果 |
| V get (long timeout, TimeUnit unit) | 用于在指定时间内获取执行结果 |
♻️4. Thread 类 与 Runnable 接口 实现多线程对比
🌈多线程的实现方式有3种，其中Runnable 接口和 Callable 接口实现多线程的方式基本相同，主要区别就是Callable接口中的方法有返回值而 Runnable 接口中的方法没有返回值。
通过继承 Thread 类和实现 Runnable 接口实现多线程方式会有一定的区别
下面通过一个应用场景来分析说明：
- 假设售票厅有 2 个窗口可发售某日某次列车的 3 张车票。
- 这时，3 张车票可以看作共享资源；2 个售票窗口同时售票，可以看作 2 个线程同时运行。
- 为了更直观地显示窗口的售票情况，可以调用 Thread 类的 currentThread() 方法获取当前线程的实例对象，然后调用 getName() 方以获取线程的名称。
（1）首先通过继承 Thread 类的方式创建多线程来演示售票情景，如下：
java
class TicketWindow extends Thread{
private int tickets = 3;
public void run(){
while (tickets > 0){
Thread t = Thread.currentThread(); // 获取当前线程
String t_name = t.getName(); // 获取当前线程名字
System.out.println(t_name + "正在发售第 " + tickets-- + " 张票");
}
}
}
public class thread_ticket {
public static void main(String[] args) {
new TicketWindow().start();
new TicketWindow().start();
}
}运行结果如下：
从上图可以看出，每张票都被打印了 2 次。出现这个现象的原因是 2 个线程没有共享 3 张票，而是各自出售了 3 张票
- 在程序中创建了2 个 TicketWindow 对象，就等于创建了 2 个售票线程，每个线程中都有 3 张票，每个线程在独立地处理各自的资源。
**需要注意的是：**上面的每个线程都有自己的名字，主线程默认的名字是main，用户创建的第一个线程的名字默认为Thread-0，第二个线程的名字默认为Thread-1，以此类推。
由于现实中铁路系统的车票资源是共享的，因此上面的运行结果显然不合理
为了保证资源共享 ，在程序中只能创建一个售票对象，然后开启多个线程运行同一个售票对象的售票方法，简单来说，就是 2 个线程运行同一个售票程序
- 用Thread类创建多线程，无法保证多个线程对共享资源的正确操作
- 而Runnable接口可以保证多个线程对共享资源的正确访问。接下来，通过实现Runnable 接口的方式实现多线程的创建。
修改代码使用构造方法 **Thread(Runnable target, String name)**在创建线程对象时指定线程名称
java
class TicketWindow implements Runnable{
private int tickets = 3;
public void run(){
while (tickets > 0){
Thread t = Thread.currentThread(); // 获取当前线程
String t_name = t.getName(); // 获取当前线程名字
System.out.println(t_name + "正在发售第 " + tickets-- + " 张票");
}
}
}
public class thread_ticket {
public static void main(String[] args) {
TicketWindow tw = new TicketWindow();
new Thread(tw, "窗口1").start();
new Thread(tw, "窗口2").start();
}
}运行结果如下：
**注意：**Thread 类下 也可以实现资源共享，还记得我们之前学的 static全局共享嘛，我们可以给 ticket 票加上这个属性，就可以使所有窗口共享资源了，如下：
三、后台线程
🔥 在多线程中，主线程如果不等待子线程的返回结果，那么主线程与子线程没有先后顺序，有可能主线程先结束了，子线程还没结束。
- 在这样的情况下，虽然主线程结束了，但整个程序进程是不会结束的，因为子线程还在执行。
💧 有人可能会认为，当 main() 方法中创建并启动的 2 个新线程的代码执行完毕后，主线程也就随之结束了。然而，通过程序的运行结果可以看出，虽然主线程结束了，但整个Java程序却没有随之结束，仍然在执行售票的代码。
对Java程序来说，只要还有一个前台线程在运行，这个进程就不会结束；如果一个进程中只有后台线程运行，这个进程就会结束。
🎐注意：这里提到的前台线程和后台线程是一种相对的概念
- 新创建的线程默认是前台线程
- 如果某个线程对象在启动之前执行了 setDaemon(true)语句，这个线程就变成了后台线程。
java
class DemoThread implements Runnable{
public void run() {
while(true){
System.out.println(Thread.currentThread().getName() + "---在运行");
}
}
}
public class thread_back {
public static void main(String[] args) {
// 判断是否为后台线程
System.out.println("main 线程是后台线程嘛？ --> " + Thread.currentThread().isDaemon());
DemoThread dt = new DemoThread();
Thread thread = new Thread(dt, "后台线程");
System.out.println("thread 线程默认是后台线程嘛？ --> " + thread.isDaemon());
// 将线程 thread 对象设置为 后台线程
thread.setDaemon(true);
thread.start();
for(int i = 1;i <= 3; i++) {
System.out.println(i);
}
}
}上面演示了一个后台线程结束的过程，运行如下
此时结果竟然没有出现死循环的情况，分析如下：
- 如果将线程thread设置为后台线程，当前台主线程循环输出任务执行完毕后，整个进程就会结束，此时Java虚拟机也会通知后台线程结束
- 由于后台线程从接收指令到作出响应需要一定的时间，因此，输出了几次 **"后台线程---在运行"**语句后，后台线程也结束了
- 由此说明：在进程中不存在前台线程时，整个进程就会结束
注意：要使某个线程设置为后台线程，必须在该线程启动之前进行设置，也就是说 setDaemon() 方法必须在 start() 方法之前进行调用，否则后台进程设置无效
四、 线程创建变形（了解）📚
💫 1. 匿名内部类创建 Thread 子类对象
java
public static void main(String[] args) {
// 匿名内部类 继承 Thread，重写run
Thread t =new Thread() {
@Override
public void run() {
System.out.println("使用匿名类创建 Thread 子类对象");
}
};
t.start();
System.out.println("main （） 主方法");
}💫 2. 匿名内部类创建 Runnable 子类对象
java
public static void main(String[] args) {
// 匿名内部类 实现 Runnable，重写run
Thread t = new Thread(new Runnable(){
@Override
public void run() {
System.out.println("使用匿名类创建 Runnable 子类对象");
}
});
t.start();
System.out.println("main （） 主方法");
}💫 3. lambda 表达式
lambda 表达式可以简化多线程的创建和调用过程，在创建线程时候可以指定线程调用的方法，格式如下：
java
Thread t = new Thread(()->{
}
});使用如下：
java
public static void main(String[] args) {
Thread t = new Thread(() ->{
System.out.println("lambda 表达式创建 Runnable 子类对象");
});
t.start();
System.out.println("main （） 主方法");
}5. 多线程的优势 -- 增加运行速度💦
可以观察多线程在一些场合下是可以提高程序的整体运行效率的。
- 使用 System.nanoTime() 可以记录当前系统的 纳秒 级时间戳.
- serial 串行的完成一系列运算
- concurrency 使两个线程并行的完成同样的运算.
java
public class thread_advantage {
private static void concurrency() throws InterruptedException {
long begin = System.nanoTime();
// 利用一个线程计算 a 的值
Thread thread = new Thread(new Runnable(){
@Override
public void run() {
int a = 0;
for (long i = 0; i < count; i++) {
a--;
}
}
});
thread.start();
// 主线程内计算 b 的值
int b = 0;
for (long i = 0; i < count; i++) {
b--;
}
// 等待 thread 线程运行结束
thread.join();
// 统计耗时
long end = System.nanoTime();
double ms = (end - begin) * 1.0 / 1000 / 1000;
System.out.printf("并发: %f 毫秒%n", ms);
}
private static void serial() {
// 全部在主线程内计算 a、b 的值
long begin = System.nanoTime();
int a = 0;
for (long i = 0; i < count; i++) {
a--;
}
int b = 0;
for (long i = 0; i < count; i++) {
b--;
}
long end = System.nanoTime();
double ms = (end - begin) * 1.0 / 1000 / 1000;
System.out.printf("串行: %f 毫秒%n", ms);
}
// 多线程并不一定就能提高速度，可以观察，count 不同，实际的运行效果也是不同的
private static final long count = 10_0000_0000;
public static void main(String[] args) throws InterruptedException {
// 使用并发方式
concurrency();
// 使用串行方式
serial();
}
}
// 运行结果如下：
并发: 381.155400 毫秒
串行: 674.797500 毫秒6. 小结📖
以上我们就把线程的创建、后台线程、以及进程与线程的区别讲啦，希望大家可以通过这篇文章打开对多线程学习的大门，后面我会继续更新多线程的相关知识的呀
【*★,°*:.☆(￣▽￣)/$:*.°★* 】那么本篇到此就结束啦，如果我的这篇博客可以给你提供有益的参考和启示，可以三连支持一下 ！！