java中进程的详细解析(含实例代码)

一、操作系统

操作系统是计算机中的一个重要软件。

说到操作系统，它本质上是一个搞管理的软件。管什么呢？管各种硬件设备，同时给应用程序提供一个稳定的运行环境——即便某个程序崩溃了，也不会影响其他程序继续执行。这才是操作系统最核心的价值所在。

操作系统中一个非常重要的概念：进程。

简单来说，运行起来的程序就叫进程。站在操作系统的角度，怎么管理这些进程呢？无非两步：第一步，先描述——用结构体把进程的核心属性都记录下来，这个结构体就是进程控制块（PCB），它非常大，属性非常多。第二步，再把多个进程组织起来——比如Linux操作系统就用链表的方式，把每个PCB串在一起。这样一来，整个管理体系就通顺了。

别忘了，操作系统本身也是一个软件，也是由一系列指令构成的。启动时，CPU依次执行操作系统上的指令（引导操作系统起来）。所有的软件本质上都得靠CPU来执行，而CPU具体执行哪些指令，一定程度上受操作系统的影响。

另外，进程在运行过程中，经常需要和硬盘打交道。硬盘上的数据都是以文件的形式组织的，进程读写文件时就得先打开文件。每个打开的文件相关信息都保存在文件描述符中，每一项对应一份打开的文件。有意思的是，操作系统会把很多资源抽象成文件来表示——比如网卡，操作系统管理网卡时，也是当作“文件”一样来管理的。

二、进程的运行

进程的运行自然离不开硬盘、网卡等硬件设备，但执行指令的核心还是CPU。

进程是操作系统中负责分配CPU的基本单位。这里有一个关键机制叫分时复用：把一个单位时间切成很多份，分别执行不同进程的指令——第一份执行进程1，第二份执行进程2……因为CPU运行速度极快，人眼根本察觉不到切换，看起来就像同时执行一样。

• 如果多个进程在一个CPU核心上轮流执行，这叫“并发执行”。
• 如果多个进程在多个CPU核心上同时执行，这叫“并行执行”。

进程的状态也很有讲究。常见的有：新建（New）、可运行（RUNNABLE）、阻塞（BLOCKED）、等待（WAITING）、超时等待（TIMED_WAITING）、终止（TERMINATED）。其中两个典型状态是：就绪状态——随时可以到CPU上执行；阻塞状态——当前不适合到CPU上执行。

进程还有优先级，这是为了保证需要大量CPU资源的进程能正常执行。此外，因为存在进程调度，一个进程执行一会就得让出CPU，所以需要保存上次执行的“上下文”——包括CPU寄存器中记录的中间状态。这些信息会被存放在内存中的PCB里，恢复时再把PCB中保存的属性填回寄存器。

最后还有记账信息，其实就是统计功能——统计每个进程在CPU上运行了多久。如果发现某个进程很久没吃到CPU资源，系统就会给它资源倾斜，防止它饿死。

三、多线程

进程整体是一个比较“重”的概念，创建和销毁进程的开销都很大。为了解决这个问题，引入了线程——也就是轻量级进程，创建和销毁的开销小得多。

每个进程都相当于一个要执行的任务，每个线程也是一个要执行的任务。进程包含线程，每个进程里至少有一个或多个线程。进程是操作系统资源分配的基本单位，进程内部所包含的多个线程之间，会共享内存资源、硬盘资源和网络带宽。

进程创建时需要申请资源，销毁时释放资源——这属于重量级操作，代价大、耗时长。但对于线程来说，只有第一个线程创建时（和进程一起创建）会申请资源，后续再创建线程就不再手动申请资源了。只有当所有线程都销毁（即进程销毁）时，资源才会被释放。换句话说，资源在进程创建时就一次性分配好了，后续线程的创建和销毁都在这一层进行，只有进程被销毁，这些资源才会被回收。

关于线程的调度，是随机的，我们的程序感知不到，也干预不了。

那怎么提高效率？

引入更多线程确实能提升效率，但资源就那么多。引入过多线程时，上下文切换的开销会随之增长，调度开销反而会拖累程序性能。更要命的是，如果一个线程抛出异常且没有被捕获，会直接带走整个进程，所有线程都无法继续运行。所以，多线程并不是越多越好，需要权衡。

下面看两种常见的线程创建方式：

• 继承Thread，重写run方法

class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("hello");
        try{
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            // throw new RuntimeException(e); // 处理异常的手段：抛出异常，导致程序异常终止
            break;
        }
    }
}

public class Test {
    public static void main(String[] args) {
        Thread t = new MyThread();
        t.start(); // 开启线程
    }
}

其中 Thread.sleep() 会让线程休眠。注意：Thread.sleep(0) 不是休眠0毫秒，而是让当前线程主动放弃CPU资源，给别的线程用。另外，在 run() 方法内，Thread.sleep() 会抛出 InterruptedException，但无法用 throws 声明，只能使用 try{} catch{} 来捕获。

• 每个线程调度的顺序是随机的，无法预测——也就是“抢占式执行”。

创建线程的另一种方法：

1. 继承 Thread，重写 run
2. 实现 Runnable 接口，重写 run

看个例子：

class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("我自己的 Runnable 的 run 方法");
    }
}
public class Deano01 {
    public static void main(String[] args) {
        Runnable r1 = new MyRunnable();
        Thread t1 = new Thread(new MyRunnable());
        Thread t2 = new Thread(r1);
        t1.start();
        t2.start();
    }
}

class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("我自己的 Thread 的 run 方法");
    }
}
public class Deano01 {
    public static void main(String[] args) {
        // 1. 自己实现一个自己的Thread类
        Thread t = new MyThread();
        t.start();
        // 2. 使用 lambda 表达式
        Thread t1 = new Thread(() -> {
            System.out.println("我自己的 Thread 的 run 方法");
        });
    }
}

Runnable 接口里只有一个无参返回值的 run 方法，所以可以用 lambda 表达式直接写 () -> { 要执行的代码 }，括号里没有参数。

总结