Java内功修炼(1)——时光机中的并发革命：从单任务到Java多线程

1.进程&线程

1.1 背景介绍

• 1950年代，计算机系统通常是单任务的。早期计算机一次只能执行一个程序，需要人工切换。这种设计简单但效率低下
• 1960年代，多任务系统的概念开始萌芽。早期的大型机操作系统如IBM的OS/360引入了分时技术，允许多个用户同时使用计算机资源。虽然计算机实际一次只能干一件事，但靠这种“闪电式切换”，用户感觉电脑在同时处理多个任务
• 1970年代，Unix操作系统诞生，采用了多任务设计。Unix通过进程调度和时间片轮转机制，允许多个程序并发执行。这一设计成为现代多任务系统的基础

单任务(进程)系统： 同一时间只能运行一个程序或任务，任务必须按顺序完成。用户需等待当前任务结束后才能启动新任务。系统资源由一个任务独占，缺乏并发能力，适用于简单应用场景
多任务(进程)系统：允许同时运行多个程序或任务，通过时间片轮转或优先级调度实现并发

• 协同式：应用程序需要主动释放CPU资源。设计简单，但稳定性较差
• 抢占式(现代主流)：由操作系统强制分配资源。操作系统可以强制中断任务，确保系统响应能力，进一步提高了并发性能。现代操作系统如Windows、Linux均采用抢占式多任务，支持更高效的资源利用和用户体验

1.2 进程/任务

进程(Process)/任务(Task)：进程是计算机中正在运行的程序的实例(应用程序与进程的关系近似于Java中类和对象的关)，是操作系统进行资源分配的基本单位

• 应用程序 ≈ 类的代码定义(静态模板)
• 进程 ≈ 类的运行时实例/对象(动态实体)

打开任务管理器，这里显示的每一个运行中的exe(可执行文件)，就叫做进程

当一个进程被创建的时候，操作系统会为它创建一个/多个PCB(Process Control
Block进程控制块)，类似C语言的结构体/Java中的类，PCB里面会存放该进程的各种属性

• PID：进程的id，可以认为是进程的身份标识，每个进程的id是独一无二的，不能重复
• 内存指针：指向的空间就是该进程创建时所申请的内存空间，指明了这个空间中哪些位置存放数据，哪些位置存放指令/代码
• 文件描述符表：文件描述符表通常是一个数组或链表，每个节点对应一个文件描述符，进程通过文件描述符来访问文件，实现进程对文件的增删查改等操作
  
• 状态
  • 就绪状态：进程的资源准备完成，随时可以运行
  • 运行状态：正在运行
  • 阻塞状态：当进程等待某个事件(如Scanner等待用户输入)时，进程暂停执行， 等待用户输入完成
  • 终止状态：进程执行完毕或被终止，操作系统会释放进程占用的资源
• 优先级：当存在多个进程时，优先级高的进程优先执行，优先级低的进程需要等待
• 记账信息：记录进程已使用的系统资源，如CPU，内存等设备的使用情况
• 上下文信息：进程在被调度执行前的状态信息，以便进程可以从上次暂停的地方继续执行

1.3 进程优缺点&线程

优点：

• 独立性：每个进程拥有独立的地址空间和资源，一个进程崩溃不会直接影响其他进程的运行，提高了系统的稳定性
• 资源隔离：操作系统为每个进程分配独立的资源(如内存、文件描述符等)，避免资源竞争和冲突，增强了安全性

缺点：

• 资源开销大：创建和销毁进程需要分配独立的地址空间和资源，上下文切换涉及保存和恢复大量寄存器状态，性能损耗较高
  • 1.创建进程，以及PCB
  • 2.连接各个进程，利用链表或者其他数据结构将PCB连接起来
  • 3.删除和增加进程，将该进程的PCB从链表中删除或者插入
    

线程(Thread)/轻量级进程：由操作系统调度，不用额外分配资源，是操作系统调度执行的基本单位。一个进程可以包含多个线程，所有线程共享进程的资源(由线程控制块TCB管理)，但每个线程拥有独立的执行栈和程序计数器
优点：

• 轻量级：线程的创建、切换和销毁比进程更高效
• 并发执行：多线程允许程序在同一时间内执行多个任务(任务和进程是否相等需要根据具体语境判断，这里的任务指的是代码块)，提高CPU利用率
• 共享资源：线程可以直接访问所属进程的全局变量、堆内存等

缺点：

• 稳定性风险：单个线程的崩溃可能导致整个进程终止，因为线程间缺乏隔离性
• 资源竞争与同步问题：线程共享同一进程的内存空间和资源，多个线程同时访问共享数据时可能引发竞争条件，导致数据不一致。必须使用锁、信号量等同步机制，增加了编程复杂度，且不当使用可能引发死锁或性能下降

2.Java中的线程实现:Thread类

2.1 创建线程

构造方法如下:

1.直接继承Thread类
优点:

• 实现简单，直接重写run()方法即可定义线程任务

缺点:

• 线程逻辑与Thread类耦合，不利于代码复用
• Java单继承特性限制了扩展性，无法再继承其他类

//Thread类实现了Runnable接口,所以需要重写run方法class MyThread extends Thread{ @Override public void run() { while (true) { System.out.println(\"Hello MyThread\"); try { Thread.sleep(1000); } catch (InterruptedException e) { throw new RuntimeException(e); } } }}public class ThreadDemo { public static void main(String[] args) { Thread thread = new MyThread(); //启动线程 thread.start(); }}

2.实现Runnable接口
优点:

• 避免单继承限制，可同时实现其他接口或继承类
• 线程任务与Thread解耦，便于复用

缺点:

• 需额外创建Thread类实例来启动线程，代码稍显冗余

class MyRunnable implements Runnable{ @Override public void run() { while (true){ System.out.println(\"Hello MyRunnable\"); try { Thread.sleep(1000); } catch (InterruptedException e) { throw new RuntimeException(e); } } }}public class ThreadDemo { public static void main(String[] args) { Thread thread = new Thread(new MyRunnable()); //启动线程 thread.start(); }}

3.匿名内部类创建Runnable子类对象
优点:

• 可直接访问外部类的final或有效final变量(变量捕获)

缺点:

• 代码可读性较差，尤其是逻辑复杂时

public class ThreadDemo { public static void main(String[] args) throws InterruptedException { Thread thread = new Thread(){ //匿名内部类 @Override public void run() { while (true) {  System.out.println(\"Hello Thread\");  try { Thread.sleep(1000);  } catch (InterruptedException e) { throw new RuntimeException(e);  } } } }; thread.start();}

4.lambda表达式创建Runnable子类对象
优点:

• 可直接访问外部类的final或有效final变量(变量捕获)

缺点:

• 仅适用于接口中只有一个抽象方法的情况

public class ThreadDemo { public static void main(String[] args) { Thread thread = new Thread(()->{  while (true){  System.out.println(\"Hello Thread\");  try {  Thread.sleep(1000);  } catch (InterruptedException e) {  throw new RuntimeException(e);  }  } }); thread.start(); }}

2.2 获取线程名字和id

public class ThreadDemo { public static void main(String[] args) { Thread thread = new Thread(()->{}); //获取线程id System.out.println(thread.getId()); //获取线程name System.out.println(thread.getName()); }}

2.3 判断线程是否存活

public class ThreadDemo { public static void main(String[] args) { Thread thread = new Thread(()->{ try { Thread.sleep(1000); } catch (InterruptedException e) { throw new RuntimeException(e); } }); //false,线程还没启动 System.out.println(thread.isAlive()); thread.start(); //true,线程正在执行任务 System.out.println(thread.isAlive()); try { Thread.sleep(2000); } catch (InterruptedException e) { throw new RuntimeException(e); } //false,线程结束 System.out.println(thread.isAlive()); }}

2.4 前台/后台线程

前台线程：会阻止进程终止，即使主线程执行完毕，只要存在前台线程仍在运行，进程会继续运行直到所有前台线程完成任务。默认情况下，主线程是前台线程，通过Thread类创建的线程默认也是前台线程
后台线程：不会阻止进程终止，当所有前台线程结束时，后台线程会被自动终止，无论是否完成任务

public class ThreadDemo { public static void main(String[] args) throws InterruptedException { Thread thread = new Thread(()->{ while (true) { try {  Thread.sleep(1000);  System.out.println(\"Hello Thread\"); } catch (InterruptedException e) {  throw new RuntimeException(e); } } }); //把thread设置为后台线程，不会阻止主线程的结束,thread线程会伴随main线程的结束而结束 thread.setDaemon(true); thread.start(); System.out.println(\"Hello Main\"); }}

运行结果：Hello Main

2.5 详解start和run

start方法：用于启动一个新线程，新线程会执行run方法中的代码。每个线程只能调用一次start，重复调用会抛出IllegalThreadStateException(无论该线程是否执行完任务)

public class ThreadDemo { public static void main(String[] args) throws InterruptedException { Thread thread = new Thread(()->{ for (int i = 0; i < 5; i++) { System.out.println(\"Hello Thread\"); try {  Thread.sleep(100); } catch (InterruptedException e) {  throw new RuntimeException(e); } } }); //开启新线程,thread线程执行run方法 thread.start(); for (int i = 0; i < 5; i++) { System.out.println(\"Hello Main\"); Thread.sleep(100); } }}

run方法：直接调用run方法不会创建新线程，而是在当前线程中执行run方法的代码

public class ThreadDemo { public static void main(String[] args) throws InterruptedException { Thread thread = new Thread(()->{ for (int i = 0; i < 5; i++) { System.out.println(\"Hello Thread\"); try {  Thread.sleep(100); } catch (InterruptedException e) {  throw new RuntimeException(e); } } }); //main线程执行run方法 thread.run(); for (int i = 0; i < 5; i++) { System.out.println(\"Hello Main\"); Thread.sleep(100); } }}

2.6 线程休眠

Thread.sleep：是Java中用于暂停当前线程执行的一个静态方法。它允许线程在指定的时间内进入休眠状态，期间不会占用CPU资源。休眠结束后，线程会重新进入就绪(RUNNABLE)状态，等待调度执行

//毫秒级精确度//需要处理InterruptedException(编译时异常)public static native void sleep(long millis) throws InterruptedException;//纳秒级精确度public static void sleep(long millis, int nanos)throws InterruptedException

知识回顾：

• main方法中：既可以throws声明异常，也可以try-catch异常
• run方法中：只能try-catch异常，因为子类重写父类方法时不能修改父类方法的方法签名

2.7 currentThread：获取当前线程实例

在继承Thread 类的自定义线程类中，可以通过this关键字直接访问当前线程的属性和方法

class MyThread extends Thread{ @Override public void run() { System.out.println(this.getId() + \" \" + this.getName()); }}public class ThreadDemo { public static void main(String[] args) { Thread thread = new MyThread(); thread.start(); }}

在使用Runnable接口或Lambda表达式创建线程时，无法直接使用this获取线程信息，因为this指向的是Runnable实例而非线程对象。应调用 Thread.currentThread()获取当前线程的引用

public class ThreadDemo { public static void main(String[] args) { Thread thread = new Thread(()->{ Thread t1 = Thread.currentThread(); System.out.println(t1.getId()+ \" \" + t1.getName()); }); thread.start(); }}

2.8 变量捕获

• 1.Java的线程模型：栈帧中的局部变量是线程私有的，这意味着每个线程都有自己的栈帧，局部变量存储在栈帧中，一个线程不得访问另一个线程中的局部变量
• 2.变量捕获(Variable Capture)：通常与Lambda表达式和匿名内部类相关，允许捕获外部作用域的变量，但这些变量必须是final修饰或事实final

结合以上两点，变量捕获机制允许一个线程获取另一个线程中的final变量
在上述代码中，thread线程捕获到main线程中的isQuit变量，本质上是将isQuit变量拷贝到thread线程中，而不是直接访问main的栈帧(避免因变量的生命周期而可能产生的线程安全问题)

如果允许匿名内部类或lambda表达式访问并修改局部变量，就会导致变量逃逸(escape)，即变量的引用或值被传递到栈帧之外造成栈中变量的内存地址泄漏，这种情况会引发严重的安全问题，因为原本被Java线程模型规定为线程私有的数据可能会被并发访问

2.9 终止线程

通过修改类变量来终止线程
缺点：

• 类变量属于整个进程的公共变量，访问时需要注意线程安全问题
• 类变量无法唤醒线程中的sleep方法

public class ThreadDemo { public static boolean isQuit = false; public static void main(String[] args) { Thread thread = new Thread(()->{ while (!isQuit){ System.out.println(\"Hello Thread\"); try {  Thread.sleep(1000); } catch (InterruptedException e) {  throw new RuntimeException(e); } } System.out.println(\"Over Thread\"); }); thread.start(); try { Thread.sleep(2000); } catch (InterruptedException e) { throw new RuntimeException(e); } isQuit = true; }}

interrupt()：是 Java中用于中断线程的方法。它的核心作用是向目标线程发送一个中断信号，但并不会直接终止线程的执行。需要主动检查中断状态并决定如何响应中断

• interrupted()：检查当前线程的中断状态，并清除中断标志(即调用后中断状态会被重置为false)
• isInterrupted()：检查线程的中断状态，但不会清除中断标志(即调用后不改变中断状态)，仅返回当前状态

public class TreadDemo { public static void main(String[] args) { Thread thread = new Thread(() -> { while (!Thread.currentThread().isInterrupted()) { System.out.println(\"Hello Thread\"); try {  Thread.sleep(1000); } catch (InterruptedException e) {  e.printStackTrace();  break; } } System.out.println(\"Over Thread\"); }); thread.start(); try { Thread.sleep(2000); } catch (InterruptedException e) { throw new RuntimeException(e); } //终止线程,并唤醒线程中的sleep thread.interrupt(); }}

2.10 join

join方法：用于等待线程执行完成。调用某个线程的join方法后，当前线程会被阻塞，直到目标线程执行完毕

方法 说明 join() 等待线程无限期执行完成 join(long millis) 等待线程执行完成，但最多等待millis毫秒 join(long millis, int nanos) 等待线程执行完成，但最多等待millis毫秒+nanos纳秒

public class ThreadDemo { public static void main(String[] args) throws InterruptedException { Thread thread = new Thread(()->{ for (int i = 0;i < 3;i++){ System.out.println(\"Hello Thread\"); try {  Thread.sleep(1000); } catch (InterruptedException e) {  throw new RuntimeException(e); } } System.out.println(\"Over Thread\"); }); thread.start(); //main等待thread线程执行完毕 thread.join(); //main线程恢复执行 System.out.println(\"Hello Main\"); }}

执行结果：
Hello Thread
Hello Thread
Hello Thread
Over Thread
Hello Main