操作系统概念

这一课你将能做到

1. 区分进程与线程，解释上下文切换的成本，以及 Java 线程与操作系统线程的关系
2. 描述 CPU 调度、虚拟内存、分页与缺页中断的基本思想
3. 理解文件系统的组织方式，以及互斥锁、信号量、条件变量分别解决什么问题

为什么要学

操作系统是「管家」：一套硬件，几百个程序争抢 CPU、内存、磁盘，它负责让大家「看似同时」运行、互不踩踏。Java 后端遇到的大量线上问题，根因都在这个层面：

• 接口 RT（响应时间）毛刺：可能是线程被调度挂起、上下文切换、缺页中断
• 机器内存没满但应用报 OOM：虚拟内存与 JVM 内存限制的交互
• 线程池开多大？开多了反而更慢：调度与切换成本
• 磁盘写了一半机器掉电：文件系统与日志（journal）如何保证一致性

判题平台更是操作系统知识的密集场景：每份提交都要隔离执行、限制 CPU/内存/时间、回收工作目录。理解进程线程与调度，才能正确设计执行沙箱和线程池。

先建立图像

进程与线程
┌─────────────── 进程 Process（资源分配单位）──────────────┐
│ 独立的地址空间：代码段/数据段/堆                          │
│ ┌线程1(栈+寄存器)┐ ┌线程2(栈+寄存器)┐ ┌线程3┐           │
│ │ 共享进程的堆和文件描述符，各自有栈    │                 │
└───────────────────────────────────────────────────────┘
  进程间内存隔离（通信要靠管道/Socket/共享内存）
  同进程线程共享内存（通信快，但要处理并发安全）

并发「同时」的真相（单核）
  线程A ▌▌    ▌▌▌       CPU 在 A/B/C 间快速切换
  线程B    ▌▌    ▌▌     时间片 time slice（毫秒级）
  线程C      ▌▌    ▌▌

虚拟内存
  进程看到的：0 ........ 连续的虚拟地址空间
       ↓ MMU 查页表翻译 ↓
  物理内存的散页 / 暂存到磁盘的交换区

跟着做

步骤 1：观察进程和线程

public class ProcessThreadDemo {
    public static void main(String[] args) {
        long pid = ProcessHandle.current().pid();
        System.out.println("当前 JVM 进程 PID = " + pid);

        // 一个进程里开两个线程：它们共享 main 里的变量
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 3; i++) {
                System.out.println("线程A: " + i);
            }
        }, "thread-A");

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 3; i++) {
                System.out.println("线程B: " + i);
            }
        }, "thread-B");

        t1.start();
        t2.start();
        // 输出顺序是交错的、不保证的——这就是并发：调度顺序由操作系统决定
    }
}

运行后再开一个终端，Windows 执行 tasklist | findstr java，Linux/macOS 执行 ps -ef | grep java，能看到这个 JVM 进程；JDK 自带的 jstack <pid> 可以列出进程内所有线程及其栈。关键认知：Java 传统线程（java.lang.Thread）在主流 JDK 上一对一映射操作系统内核线程，创建、阻塞都有内核开销，所以不能为每个请求新建线程，要用线程池（Java 21 的虚拟线程则是另一套轻量模型）。

步骤 2：体会上下文切换的代价

import java.util.concurrent.CountDownLatch;

public class SwitchCost {
    public static void main(String[] args) throws Exception {
        int n = 200_000;

        // 对照组：两个线程各跑各的
        CountDownLatch latch1 = new CountDownLatch(2);
        long t1 = System.nanoTime();
        for (int t = 0; t < 2; t++) {
            new Thread(() -> {
                for (int i = 0; i < n; i++) { Math.sin(i); }
                latch1.countDown();
            }).start();
        }
        latch1.await();
        long t2 = System.nanoTime();

        // 实验组：两个线程用一根锁反复交替唤醒（制造大量切换/争用）
        final Object lock = new Object();
        CountDownLatch latch2 = new CountDownLatch(2);
        for (int t = 0; t < 2; t++) {
            new Thread(() -> {
                for (int i = 0; i < n; i++) {
                    synchronized (lock) { lock.notifyAll(); }  // 频繁让出与争用
                }
                latch2.countDown();
            }).start();
        }
        latch2.await();
        long t3 = System.nanoTime();

        System.out.println("无争用(ms): " + (t2 - t1) / 1_000_000);
        System.out.println("强争用(ms): " + (t3 - t2) / 1_000_000);
    }
}