什么是线程和进程?

何为进程?

进程是操作系统中一个独立的运行单元，是程序的一次执行过程。它是资源分配的基本单位，每个进程都有自己的内存空间、数据栈和其他资源。进程是动态的，从创建、运行到消亡构成了进程的生命周期。

在 Java 中，当我们启动 main 函数时，实际上是启动了一个 JVM 的进程，main 函数所在的线程即为主线程。简单来说，进程是一个程序的实例。例如，当我们在 Windows 系统中启动多个 .exe 文件，每个文件都会对应一个独立的进程。

何为线程?

线程是比进程更小的执行单位，线程是进程的子集，一个进程可以包含多个线程。线程共享进程的堆内存和方法区资源，但每个线程都有自己的程序计数器、虚拟机栈和本地方法栈。因此，系统在创建或切换线程时，开销要比进程小得多，线程也因此被称为轻量级进程。

Java 多线程示例

Java 程序天生支持多线程。我们可以通过 Java 的 JMX（Java Management eXtensions） 来查看一个普通 Java 程序中有哪些线程。

java

import java.lang.management.ManagementFactory;
import java.lang.management.ThreadInfo;
import java.lang.management.ThreadMXBean;

public class MultiThread {
    public static void main(String[] args) {
        // 获取 Java 线程管理 MXBean
        ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();
        // 不需要获取同步的 monitor 和 synchronizer 信息，仅获取线程和线程堆栈信息
        ThreadInfo[] threadInfos = threadMXBean.dumpAllThreads(false, false);
        // 遍历线程信息，仅打印线程 ID 和线程名称信息
        for (ThreadInfo threadInfo : threadInfos) {
            System.out.println("[" + threadInfo.getThreadId() + "] " + threadInfo.getThreadName());
        }
    }
}

上述程序输出类似如下（实际输出可能根据 JVM 环境和操作系统不同而有所不同）：

txt

[5] Attach Listener
[4] Signal Dispatcher
[3] Finalizer
[2] Reference Handler
[1] main

从输出内容可以看出：一个 Java 程序的运行是 main 线程和多个其他线程同时运行。

深入理解线程和进程

为了更好地理解进程和线程的区别及其设计目的，我们可以通过源码分析 JVM 是如何管理线程的。

线程的生命周期

线程在其生命周期中会经历以下状态：

• NEW：新创建的线程，尚未启动。
• RUNNABLE：运行中的线程，正在执行 run 方法的 Java 代码。
• BLOCKED：被阻塞的线程，等待一个监视器锁。
• WAITING：等待的线程，等待其他线程做出特定动作。
• TIMED_WAITING：具有指定等待时间的线程。
• TERMINATED：已退出的线程。

我们可以通过 Thread 类的 getState 方法来获取线程的当前状态。

示例代码

java

public class ThreadStateDemo implements Runnable {
    public static void main(String[] args) {
        Thread thread = new Thread(new ThreadStateDemo());
        System.out.println("Thread state after creation: " + thread.getState());
        thread.start();
        System.out.println("Thread state after start: " + thread.getState());
    }

    @Override
    public void run() {
        System.out.println("Thread state in run method: " + Thread.currentThread().getState());
    }
}

输出如下：

txt

Thread state after creation: NEW
Thread state after start: RUNNABLE
Thread state in run method: RUNNABLE

实例应用场景

1. Web 服务器：例如，Tomcat 服务器在处理 HTTP 请求时，为每个请求分配一个线程，从而实现并发处理多个请求。

2. GUI 应用程序：在 GUI 编程中，长时间的任务（例如文件下载）可以放在后台线程中执行，而主线程负责更新 UI，以保持界面响应。

3. 数据库连接池：在高并发情况下，数据库连接池使用线程池来复用连接，从而提高性能和资源利用率。

性能对比示例

为了展示线程和进程在性能上的差异，我们可以通过创建多个线程和进程来处理相同的任务，并比较它们的执行时间：

使用线程

java

public class ThreadPerformanceTest {
    public static void main(String[] args) throws InterruptedException {
        long startTime = System.currentTimeMillis();
        
        Thread[] threads = new Thread[100];
        for (int i = 0; i < 100; i++) {
            threads[i] = new Thread(() -> {
                // 模拟任务
                for (int j = 0; j < 1000000; j++) {
                    Math.sqrt(j);
                }
            });
            threads[i].start();
        }
        
        for (Thread thread : threads) {
            thread.join();
        }
        
        long endTime = System.currentTimeMillis();
        System.out.println("Total time using threads: " + (endTime - startTime) + "ms");
    }
}

使用进程

java

public class ProcessPerformanceTest {
    public static void main(String[] args) throws IOException, InterruptedException {
        long startTime = System.currentTimeMillis();
        
        Process[] processes = new Process[100];
        for (int i = 0; i < 100; i++) {
            processes[i] = new ProcessBuilder("java", "-cp", ".", "Task").start();
        }
        
        for (Process process : processes) {
            process.waitFor();
        }
        
        long endTime = System.currentTimeMillis();
        System.out.println("Total time using processes: " + (endTime - startTime) + "ms");
    }
}

class Task {
    public static void main(String[] args) {
        // 模拟任务
        for (int j = 0; j < 1000000; j++) {
            Math.sqrt(j);
        }
    }
}

通过对比可以发现，使用线程的开销和性能要优于进程，特别是在创建和上下文切换方面。线程的轻量级特性使其在高并发场景下具有更高的性能和更好的资源利用率。

总结：

• 进程是操作系统中独立运行的单位，拥有独立的资源。
• 线程是进程中的子集，共享进程资源，但开销较小。
• Java 程序天生支持多线程，通过 JMX 可以查看系统中运行的线程。
• 在高并发场景下，使用线程相较于进程能更高效地利用资源。