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

用户11873138

发布于 2026-01-13 21:38:18

1000

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");
    }
}