w wyl123ly 的博客
MD

操作系统

66 KB 2026.10.11 原文件

操作系统

这篇笔记讲什么

操作系统(Operating System, OS)是硬件之上、应用程序之下的那层管理者。

它把 CPU、内存、磁盘、网卡这些「一堆互相打架的硬件」变成程序员可以放心使用的抽象:

进程、虚拟地址空间、文件、套接字。

本文按「抽象 → 并发 → 内存 → 存储 → IO」的主线走一遍:

用户态/内核态与系统调用、进程与线程、调度算法(含等待/周转时间手算)、

信号量与死锁(银行家算法)、分页与虚拟内存(FIFO/LRU/Clock 与 Belady 异常)、

inode 与磁盘调度、五种 IO 模型,最后附一份 Linux 实操命令清单。

读完你应该能:看懂 top 的每一项、解释为什么会有死锁、给一个场景选出合适的调度与置换算法。

一、这是什么

操作系统是管理计算机硬件资源、并为应用程序提供运行环境的系统软件。它向上下两个方向各提供一套接口:

方向提供服务例子
向下(对硬件)资源管理分配 CPU 时间片、分配/回收物理页、驱动磁盘与网卡
向上(对程序)抽象接口进程/线程、虚拟内存、文件、套接字、系统调用

它的三大核心职责:

  1. 进程管理:创建、调度、同步、通信、销毁。
  2. 内存管理:地址映射、分配回收、虚拟内存、保护与共享。
  3. 文件与 IO 管理:文件抽象、目录树、缓冲、设备驱动、中断处理。

内核(Kernel)不等于操作系统

严格说,内核是操作系统的核心,负责上述职责;而「操作系统」通常还包含 Shell、系统库、常用工具。

Ubuntu、CentOS 是发行版(Distribution),Linux 是内核。这个区分在排查问题时很重要:

「Linux 崩了」通常是内核 panic,「Ubuntu 崩了」可能只是某个用户态服务挂了。

二、为什么需要它

如果没有操作系统,写一个「同时读键盘、写磁盘、算数」的程序会是这样:

  • 你得自己写磁盘驱动、自己处理中断、自己安排寄存器;
  • 你的程序可以随意读写别人的内存,一个 bug 就搞崩整台机器;
  • 你想同时做两件事,只能手写状态机,没有任何公平性保障。

操作系统解决的核心问题可以归为四类:

问题没有 OS 的后果OS 的解法
资源有限只能跑一个程序多道程序、时间片、调度
隔离与保护程序互相破坏用户态/内核态、虚拟地址空间
抽象复杂每个程序都要写驱动文件、套接字、统一系统调用接口
并发正确性数据竞争、死锁信号量、互斥锁、管程、内存屏障

一句话动机

操作系统的本质是在有限的硬件上,用可控的开销换取「多任务、隔离、易用」。

后面所有机制(页表、调度器、文件系统)都是在这个约束下的工程折中。

三、操作系统的演化

阶段形态特征局限
手工操作插线板 / 纸带无 OS,人工切换利用率极低
批处理Batch System作业成批提交,监控程序自动切换无交互、CPU 与 IO 不能重叠
多道批处理Multiprogramming内存同时放多个作业,IO 时切换仍无交互,响应慢
分时系统Time-Sharing时间片轮转,多用户交互需要时钟中断与保护机制
实时系统Real-Time硬实时(工业控制)必须满足截止期调度复杂,吞吐量不是目标
个人/网络/分布式PC、云、容器图形界面、虚拟化、微服务隔离边界与性能开销的权衡

驱动演化的两条主线:提高资源利用率 与 缩短响应时间,两者经常互相矛盾。

单体内核 vs 微内核

Linux 是单体内核(Monolithic Kernel):文件系统、驱动、网络栈都在内核态,调用直接、性能好,但一个驱动 bug 就可能 panic。

Minix、QNX、seL4 是微内核(Microkernel):内核只保留最基础的调度与 IPC,驱动在用户态,隔离好、可靠性高,代价是 IPC 开销。

macOS 的 XNU 是混合内核(Mach + BSD)。这一取舍至今仍有争议。

四、用户态与内核态、系统调用

4.1 两种特权级

CPU 提供至少两种特权级(x86-64 有 Ring 0~3,实际只用 Ring 0 与 Ring 3):

对比项用户态(User Mode)内核态(Kernel Mode)
权限不能执行特权指令可执行所有指令
可见内存只能访问自己的虚拟地址空间可访问全部物理内存与内核空间
典型指令算术、跳转、普通访存cli/sti、hlt、修改页表基址、IO 端口读写
犯错后果自己进程被终止(Segmentation Fault)整机崩溃(Kernel Panic)
谁在运行应用程序、库内核代码、驱动

态切换(Mode Switch) 通常通过三种入口发生:系统调用(主动)、中断(异步)、异常(同步,如缺页、除零)。

4.2 系统调用(System Call)

系统调用是用户程序请求内核服务的唯一正式入口。一次调用的开销来自:

  1. 切换到内核栈、保存寄存器现场;
  2. 参数校验与权能检查(copy_from_user 等);
  3. 执行内核逻辑;
  4. 恢复现场、返回用户态(可能触发调度)。

系统调用很贵

一次系统调用的量级是 数百纳秒到数微秒(还受 Spectre/Meltdown 缓解措施影响)。

所以:逐字节 read() 读文件是灾难;日志要批量刷盘;网络 IO 要用缓冲区聚包。

/* syscall_demo.c —— 亲手调用 write(2) 与 getpid(2),观察返回值与 errno
 * 编译:gcc -O2 -Wall -o syscall_demo syscall_demo.c
 */
#include <unistd.h>      /* write, getpid */
#include <errno.h>
#include <string.h>
#include <stdio.h>

int main(void) {
    /* 系统调用失败时返回 -1 并设置 errno,绝不要忽略返回值 */
    const char *msg = "hello from write(2)\n";
    ssize_t n = write(STDOUT_FILENO, msg, strlen(msg));
    if (n == -1) {
        fprintf(stderr, "write 失败: %s\n", strerror(errno));
        return 1;
    }
    /* write 可能「短写」:只写回一部分,健壮的代码必须循环到全部写完 */
    printf("本次实际写入 %zd 字节,pid=%d\n", n, (int)getpid());

    /* 故意触发一个错误,看看 errno 长什么样 */
    if (write(-1, "x", 1) == -1) {
        printf("对非法 fd 写入失败,errno=%d (%s)\n", errno, strerror(errno));  /* EBADF=9 */
    }
    return 0;
}

下面的命令可以观察程序到底调用了哪些系统调用——排查性能问题的第一手段:

# 统计某命令的系统调用次数与耗时分布
strace -c -f ./syscall_demo

# 只看文件相关的调用,并打印时间戳
strace -e trace=openat,read,write -tt ./syscall_demo

# 直接查系统调用的手册页(第 2 节 = 系统调用,第 3 节 = 库函数)
man 2 write
man 3 printf

五、进程与线程

5.1 进程是什么

进程(Process)是程序的一次执行实例,是资源分配的基本单位。它拥有:

  • 独立的虚拟地址空间(代码段、数据段、堆、栈、共享库映射);
  • 一组资源句柄(打开的文件描述符、信号处理、套接字);
  • 至少一个执行流(主线程)。

线程(Thread)是 CPU 调度的基本单位,同一进程内的线程共享地址空间与文件描述符,但各自有独立的栈、寄存器现场与线程局部存储(TLS)。

/* fork_demo.c —— fork 创建进程、pthread 创建线程:观察地址空间是否共享
 * 编译:gcc -O2 -Wall -pthread -o fork_demo fork_demo.c
 */
#include <stdio.h>
#include <unistd.h>
#include <pthread.h>
#include <sys/wait.h>

static int g_counter = 0;

static void *thread_fn(void *arg) {
    (void)arg;
    g_counter += 100;                        /* 线程共享全局变量,能改到 */
    printf("[线程] 修改全局变量后 g_counter=%d,地址=%p\n", g_counter, (void *)&g_counter);
    return NULL;
}

int main(void) {
    /* ---- 进程:写时复制(Copy-On-Write),父子互不影响 ---- */
    int local = 1;
    pid_t pid = fork();
    if (pid == 0) {
        local = 999;                          /* 只改自己那份副本 */
        g_counter = 999;
        printf("[子进程] local=%d\n", local);
        _exit(0);                             /* 子进程用 _exit,避免重复刷新 stdio 缓冲 */
    }
    waitpid(pid, NULL, 0);
    printf("[父进程] local=%d g_counter=%d(fork 后子进程的修改不可见)\n", local, g_counter);

    /* ---- 线程:共享地址空间 ---- */
    pthread_t t;
    pthread_create(&t, NULL, thread_fn, NULL);
    pthread_join(t, NULL);
    printf("[主线程] 线程改过的 g_counter=%d(可见)\n", g_counter);
    return 0;
}

5.2 进程 vs 线程对比

对比项进程(Process)线程(Thread)
地址空间独立,互相隔离共享同一地址空间
创建/切换开销大(要切页表、刷 TLB,微秒级)小(同一地址空间,约几百纳秒~微秒)
通信方式管道、消息队列、共享内存、套接字、信号直接读写共享变量(需同步)
隔离性与健壮性一个崩溃不影响其他一个线程段错误,整个进程退出
资源占用每进程有独立页表、fd 表共享页表与 fd 表,仅独立栈与 TLS
适用场景需要强隔离(浏览器多标签、Chrome 架构)需要高并发低开销(IO 密集、计算并行)

切换开销的真实来源

进程切换贵,主要不是因为「保存寄存器」,而是:

① 换页表基址(CR3)后 TLB 失效,后续访存要重新走页表;

② 缓存局部性被破坏(Cache Pollution)。

所以高并发服务器普遍用「少量进程 + 每进程多线程」或「线程池 + 事件循环」。

5.3 进程状态机与 PCB

五状态模型:

状态英文说明
新建New正在创建,尚未进入就绪队列
就绪Ready万事俱备,只等 CPU
运行Running正在 CPU 上执行(单核同一时刻只有一个)
阻塞Blocked / Waiting等待事件(IO 完成、锁、信号),给 CPU 也不要
终止Terminated已结束,等待父进程回收(僵尸态)

合法的状态迁移:

新建 --接纳--> 就绪 --调度--> 运行 --时间片用完--> 就绪
                             运行 --请求IO/等待事件--> 阻塞 --事件完成--> 就绪
                             运行 --退出--> 终止

非法迁移

「阻塞 → 运行」是非法的:被唤醒的进程只能进入就绪队列,必须重新参与调度。

「就绪 → 阻塞」也是非法的:没在运行就不可能发起 IO 请求。

PCB(Process Control Block,进程控制块) 是内核中描述进程的数据结构(Linux 里是 struct task_struct):

字段类别内容
标识PID、PPID、UID/GID、进程组、会话
状态运行态/就绪/阻塞、退出码、信号
调度信息优先级、nice 值、时间片、调度类(CFS 的 vruntime)
内存页表基址、mm_struct、栈指针
文件打开文件表、当前工作目录、umask
上下文寄存器现场、程序计数器、内核栈指针
# 查看进程的 PCB 信息(Linux 把很多字段暴露在 /proc 下)
cat /proc/self/status          # 人类可读的进程状态汇总
ls /proc/self/task/            # 该进程的所有线程(TID)目录
cat /proc/self/maps            # 虚拟地址空间布局
ps -eLf | head                 # -L 显示线程(LWP 列)
ps -eo pid,ppid,stat,ni,cmd | head

六、CPU 调度算法

6.1 评价指标

其他指标:响应时间(首次获得 CPU 的等待)、吞吐量(单位时间完成作业数)、CPU 利用率、公平性。

6.2 算法对比

算法英文抢占优点缺点饥饿
先来先服务FCFS否简单、公平(按到达序)护航效应:长作业堵住短作业无
短作业优先SJF / SRTFSJF 否,SRTF 是平均等待时间最优(可证明)需预知运行时间;长作业可能饿死有
时间片轮转RR是响应快,适合分时时间片太小切换开销大,太大退化成 FCFS无
优先级Priority可抢占/非抢占可表达重要性低优先级饥饿有(可用老化解决)
多级反馈队列MLFQ是无需预知运行时间,兼顾交互与批处理参数多、难调优可用老化避免

时间片的选择

时间片 必须远大于上下文切换开销,否则切换本身会吃掉大部分 CPU。

经验: 取 10~100 ms,切换开销约几微秒,比例控制在 1% 以内。

若 ,RR 退化为 FCFS。

6.3 手算示例(务必自己算一遍)

设 4 个进程,同时(时刻 0)到达,服务时间如下:

进程服务时间
P15
P24
P31
P46

FCFS(按 P1→P2→P3→P4):

进程完成时刻周转时间等待时间
P1550
P2995
P310109
P4161610
平均—10.06.0

SJF(按 P3(1) → P2(4) → P1(5) → P4(6)):

进程完成时刻周转时间等待时间
P3110
P2551
P110105
P4161610
平均—8.04.0

RR(时间片 ) 的执行序列(没跑完的进程回到队尾,新到达的排在队尾):

时间片0-22-44-55-77-99-1111-1313-1515-1717-1818-2020-22
运行P1P2P3✔P4P1P2P1P4P2✔P1✔P4P4✔

(✔ 表示该进程在本片结束时完成;P3 只需 1 个时间单位,所以第一片就结束了)

进程完成时刻周转时间等待时间
P1181813
P2171713
P3554
P4222216
平均—15.511.5

从这组数字能读出什么

RR 的平均周转时间(15.5)明显差于 FCFS(10.0)与 SJF(8.0),但它的首次响应时间最好:

FCFS 下 P4 要等到时刻 10 才开始跑;RR 下 P4 在时刻 5 就拿到了第一个时间片,P3 甚至在时刻 4 就跑完了。

这说明:没有一种算法在所有指标上都最优,选择取决于你更在意吞吐量还是交互体验。

这也是 Linux 用 CFS(完全公平调度)而不是 SJF 的原因——服务器要的是公平与低延迟,而不是最短平均周转。

"""schedulers.py —— FCFS / SJF(SRTF) / RR 调度模拟,可直接运行"""
from collections import deque


def simulate_fcfs(procs):
    """procs: [(名字, 到达时间, 服务时间)],按到达时间排序后依次执行"""
    t, out = 0, []
    for name, arrive, burst in sorted(procs, key=lambda p: p[1]):
        t = max(t, arrive)                      # CPU 可能空闲等待到达
        t += burst
        out.append((name, t, t - arrive, t - arrive - burst))
    return out


def simulate_sjf(procs, preemptive=False):
    """SJF(非抢占)与 SRTF(抢占):每次都挑剩余时间最短的就绪作业

    抢占版按「1 个时间单位」推进,这样新作业一到达就能参与比较;
    非抢占版则一次把当前作业跑完,中途到达的作业只能等下一轮。
    """
    burst = {n: b for n, _, b in procs}
    arrive = {n: a for n, a, _ in procs}
    remain = dict(burst)
    t, out = 0, []

    while len(out) < len(procs):
        ready = [n for n in remain if arrive[n] <= t and remain[n] > 0]
        if not ready:
            t = min(arrive[n] for n in remain if remain[n] > 0)   # 跳到下一个到达时刻
            continue

        cur = min(ready, key=lambda n: remain[n])   # 选剩余时间最短者
        run = remain[cur] if not preemptive else 1  # 非抢占跑完,抢占只跑 1 个时间单位
        t += run
        remain[cur] -= run

        if remain[cur] == 0:
            out.append((cur, t, t - arrive[cur], t - arrive[cur] - burst[cur]))

    return sorted(out, key=lambda r: r[1])           # 按完成时刻输出,便于阅读


def simulate_rr(procs, quantum=2):
    """时间片轮转:就绪队列 FIFO,时间片用完但没跑完的进程回到队尾"""
    burst = {n: b for n, _, b in procs}
    arrive = {n: a for n, a, _ in procs}
    remain = dict(burst)
    pending = sorted(procs, key=lambda p: p[1])
    q, t, out, i = deque(), 0, [], 0

    while i < len(pending) or q:
        while i < len(pending) and pending[i][1] <= t:   # 到达的先入队
            q.append(pending[i][0])
            i += 1
        if not q:
            t = pending[i][1]                            # CPU 空闲,直接跳到下一个到达时刻
            continue

        name = q.popleft()
        run = min(quantum, remain[name])
        t += run
        remain[name] -= run

        if remain[name] == 0:
            out.append((name, t, t - arrive[name], t - arrive[name] - burst[name]))
            continue

        while i < len(pending) and pending[i][1] <= t:   # 本时间片内新到达的,先入队
            q.append(pending[i][0])
            i += 1
        q.append(name)                                   # 再把没跑完的放回队尾
    return sorted(out, key=lambda r: r[1])


def report(title, rows):
    print(f"\n== {title} ==")
    print(f"{'进程':<6}{'完成':>6}{'周转':>6}{'等待':>6}")
    for name, fin, tat, wait in rows:
        print(f"{name:<6}{fin:>6}{tat:>6}{wait:>6}")
    n = len(rows)
    print(f"平均周转 = {sum(r[2] for r in rows)/n:.2f}, "
          f"平均等待 = {sum(r[3] for r in rows)/n:.2f}")


if __name__ == "__main__":
    procs = [("P1", 0, 5), ("P2", 0, 4), ("P3", 0, 1), ("P4", 0, 6)]
    report("FCFS", simulate_fcfs(procs))
    report("SJF(非抢占)", simulate_sjf(procs, preemptive=False))
    report("RR(q=2)", simulate_rr(procs, quantum=2))

    # 到达时间不同时,SJF 的平均等待时间仍优于 FCFS(可自己改数据验证)
    procs2 = [("A", 0, 7), ("B", 2, 4), ("C", 4, 1), ("D", 5, 4)]
    report("FCFS(带到达时间)", simulate_fcfs(procs2))
    report("SJF(带到达时间)", simulate_sjf(procs2, preemptive=False))

七、进程同步

7.1 临界区与三个要求

临界区(Critical Section) 是访问共享资源的代码段。任何同步方案都必须满足:

要求英文含义
互斥Mutual Exclusion同一时刻至多一个进程在临界区内
前进Progress临界区空闲时,想进的进程必须能进,且不能被无限推迟
有限等待Bounded Waiting一个进程请求进入后,等待时间有上界(不会饿死)

忙等(Busy Waiting)的问题

用 while (flag) ; 自旋等待会空转 CPU,单核上甚至可能死锁(持锁者拿不到 CPU)。

单核场景应使用会睡眠的锁(如 futex 支持的互斥量);自旋只适合临界区极短且核数充足的情况。

/* race_demo.c —— 先看数据竞争长什么样,再用互斥量修好它
 * 编译:gcc -O2 -Wall -pthread -o race_demo race_demo.c
 */
#include <pthread.h>
#include <stdio.h>

#define N 1000000
static long counter = 0;
static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;

static void *unsafe_add(void *arg) {
    (void)arg;
    for (int i = 0; i < N; i++) counter++;      /* 非原子:load-add-store 三步 */
    return NULL;
}

static void *safe_add(void *arg) {
    (void)arg;
    for (int i = 0; i < N; i++) {
        pthread_mutex_lock(&lock);             /* 临界区:保证读-改-写整体原子 */
        counter++;
        pthread_mutex_unlock(&lock);
    }
    return NULL;
}

int main(void) {
    pthread_t t1, t2;

    counter = 0;
    pthread_create(&t1, NULL, unsafe_add, NULL);
    pthread_create(&t2, NULL, unsafe_add, NULL);
    pthread_join(t1, NULL); pthread_join(t2, NULL);
    printf("无锁:期望 %d,实际 %ld %s\n", 2 * N, counter,
           counter == 2 * N ? "" : "← 丢了更新");

    counter = 0;
    pthread_create(&t1, NULL, safe_add, NULL);
    pthread_create(&t2, NULL, safe_add, NULL);
    pthread_join(t1, NULL); pthread_join(t2, NULL);
    printf("加锁:期望 %d,实际 %ld\n", 2 * N, counter);
    return 0;
}

7.2 信号量与 P/V 操作

信号量(Semaphore) 是一个受保护的整型变量,只能通过两个原子操作访问:

操作别名语义
wait(S)P 操作 / downS--;若 则阻塞,直到有资源
signal(S)V 操作 / upS++;若有等待者则唤醒一个
  • 互斥信号量:初值 1,实现临界区。
  • 同步信号量(资源计数):初值 ,表示有 个可用资源。

PV 操作的顺序陷阱

生产者-消费者中,绝不能先 P 互斥量再 P 空槽位:

若缓冲区满,生产者持有互斥锁却阻塞在「空槽位」上,消费者进不了临界区,直接死锁。

正确顺序是「先申请资源信号量,再申请互斥量」。

7.3 生产者-消费者(有界缓冲区)

"""producer_consumer.py —— 用信号量实现有界缓冲区,可直接运行"""
import threading
import time
import random
from collections import deque

BUFFER_SIZE = 5
buffer = deque()
mutex = threading.Semaphore(1)                 # 互斥:保护 buffer 本身
empty = threading.Semaphore(BUFFER_SIZE)       # 空槽位数
full = threading.Semaphore(0)                  # 已填充槽位数


def producer(pid: int, items: int) -> None:
    for i in range(items):
        item = f"P{pid}-item{i}"
        time.sleep(random.uniform(0.01, 0.03))
        empty.acquire()                        # 先申请空槽位:满了就睡,不占锁
        mutex.acquire()
        buffer.append(item)
        print(f"生产 {item:<12} 缓冲区={list(buffer)}")
        mutex.release()
        full.release()                         # 通知消费者:多了一个可消费项


def consumer(cid: int, items: int) -> None:
    for _ in range(items):
        full.acquire()                         # 先等有数据,再抢锁
        mutex.acquire()
        item = buffer.popleft()
        print(f"    消费 {item:<12} 缓冲区={list(buffer)}")
        mutex.release()
        empty.release()                        # 归还一个空槽位
        time.sleep(random.uniform(0.02, 0.05))


if __name__ == "__main__":
    threads = [threading.Thread(target=producer, args=(1, 6)),
               threading.Thread(target=producer, args=(2, 6)),
               threading.Thread(target=consumer, args=(1, 7)),
               threading.Thread(target=consumer, args=(2, 5))]
    for t in threads:
        t.start()
    for t in threads:
        t.join()
    print("结束,剩余缓冲区:", list(buffer))

7.4 读者-写者问题

规则:允许多个读者同时读;写者与任何人互斥。

策略规则风险
读者优先只要还有读者在读,写者就等写者可能饿死
写者优先有写者等待时,新读者排在写者后读者可能饿死
公平(FIFO)按到达顺序发放实现较复杂
/* reader_writer.c —— 读者优先的读者-写者实现(用读写锁更简单,这里是原理版)
 * 编译:gcc -O2 -Wall -pthread -o rw reader_writer.c
 */
#include <pthread.h>
#include <stdio.h>
#include <unistd.h>

static int read_count = 0;
static pthread_mutex_t count_lock = PTHREAD_MUTEX_INITIALIZER;  /* 保护 read_count */
static pthread_mutex_t write_lock = PTHREAD_MUTEX_INITIALIZER;  /* 写者互斥 + 挡住读者 */
static int shared_data = 0;

static void *reader(void *arg) {
    long id = (long)arg;
    pthread_mutex_lock(&count_lock);
    if (++read_count == 1)                 /* 第一个读者负责锁住写者 */
        pthread_mutex_lock(&write_lock);
    pthread_mutex_unlock(&count_lock);

    printf("读者 %ld 读到 %d\n", id, shared_data);
    usleep(10000);

    pthread_mutex_lock(&count_lock);
    if (--read_count == 0)                 /* 最后一个读者负责放行写者 */
        pthread_mutex_unlock(&write_lock);
    pthread_mutex_unlock(&count_lock);
    return NULL;
}

static void *writer(void *arg) {
    long id = (long)arg;
    pthread_mutex_lock(&write_lock);
    shared_data++;
    printf("写者 %ld 写入 %d\n", id, shared_data);
    usleep(10000);
    pthread_mutex_unlock(&write_lock);
    return NULL;
}

int main(void) {
    pthread_t r[3], w[2];
    for (long i = 0; i < 3; i++) pthread_create(&r[i], NULL, reader, (void *)i);
    for (long i = 0; i < 2; i++) pthread_create(&w[i], NULL, writer, (void *)i);
    for (int i = 0; i < 3; i++) pthread_join(r[i], NULL);
    for (int i = 0; i < 2; i++) pthread_join(w[i], NULL);
    printf("最终 shared_data=%d\n", shared_data);
    return 0;
}

7.5 管程(Monitor)

管程把「共享数据 + 操作 + 同步」封装成一个模块,同一时刻只有一个进程能在管程内活动,同步由条件变量表达。

对比项信号量管程
同步逻辑位置分散在调用者代码里集中在管程内部
出错概率高(P/V 顺序、漏配对)低(编译器/运行时保证互斥)
语言支持通用Java 的 synchronized、C# 的 lock、Python 的 threading.Condition
条件等待wait/signal 作用于信号量wait/signal 作用于条件变量,必须与互斥锁配合
"""monitor_demo.py —— 用 Condition(管程思想)实现「等条件成立再继续」"""
import threading

class BoundedQueue:
    """管程:所有对内部 list 的访问都在同一把锁下,等待用条件变量表达"""

    def __init__(self, capacity: int):
        self._cap = capacity
        self._items = []
        self._cond = threading.Condition()      # 内置一把锁 + 等待队列

    def put(self, item) -> None:
        with self._cond:
            # 必须用 while 而不是 if:被唤醒后要重新检查条件(防虚假唤醒)
            while len(self._items) >= self._cap:
                self._cond.wait()
            self._items.append(item)
            self._cond.notify_all()

    def get(self):
        with self._cond:
            while not self._items:
                self._cond.wait()
            item = self._items.pop(0)
            self._cond.notify_all()
            return item


if __name__ == "__main__":
    q = BoundedQueue(3)
    threading.Thread(target=lambda: [q.put(i) for i in range(5)], daemon=True).start()
    print([q.get() for _ in range(5)])          # [0, 1, 2, 3, 4]

条件变量必须配 while

用 if 检查条件、被唤醒后不复查,会在虚假唤醒(Spurious Wakeup)或

「被唤醒但条件又被别人抢走」时出错。这是并发代码里最常见、最难复现的 bug 之一。

八、死锁

8.1 四个必要条件

死锁(Deadlock)必须同时满足以下四条,破坏任意一条即可预防:

条件英文含义破坏手段
互斥Mutual Exclusion资源同一时刻只能被一个进程占用尽量用可共享资源(只读文件)
占有并等待Hold and Wait持有资源的同时等待新资源一次性申请全部资源;申请不到就释放已有
不可剥夺No Preemption资源不能被强行抢走允许抢占(如 CPU、可回滚的事务)
循环等待Circular Wait存在进程-资源的环形等待链给资源编号,一律按序申请

工程上最实用的两条

① 按固定顺序加锁(破坏循环等待):例如所有代码都先锁 A 再锁 B,绝不反向。

② 加锁超时 + 重试(绕开不可剥夺):try_lock 失败就释放已有锁、退避后重试。

8.2 处理策略对比

策略英文做法代价
预防Prevention破坏四个必要条件之一资源利用率下降
避免Avoidance动态检查分配后是否仍处安全状态(银行家算法)需预知最大需求,开销大
检测与恢复Detection & Recovery定期跑检测算法,发现后杀进程/回滚检测开销 + 恢复损失
忽略Ignore(鸵鸟策略)假设不会发生,出问题就重启简单,但线上会真的发生

8.3 银行家算法

安全状态:存在一个进程执行序列,使得按该序列依次满足每个进程的最大需求都能成功。存在这样的序列就安全,安全状态一定不会死锁。

算法步骤(对每个请求 Request[i]):

  1. 若 → 出错(请求超过声明的最大需求)。
  2. 若 → 等待(资源不足)。
  3. 试探性分配:,,。
  4. 执行安全性检查;安全则正式分配,不安全则回滚并让进程等待。
"""banker.py —— 银行家算法:安全性检查 + 请求试探,可直接运行"""

def is_safe(available, allocation, need):
    """返回 (是否安全, 安全序列)。Work 为可用向量,Finish 标记已完成进程"""
    n = len(allocation)
    work = list(available)
    finish = [False] * n
    sequence = []

    while len(sequence) < n:
        progressed = False
        for i in range(n):
            if not finish[i] and all(need[i][j] <= work[j] for j in range(len(work))):
                for j in range(len(work)):
                    work[j] += allocation[i][j]     # 进程 i 完成后归还全部资源
                finish[i] = True
                sequence.append(i)
                progressed = True
                break                               # 从头再扫,保证找到的是当前可满足的
        if not progressed:
            return False, []                        # 还有进程无法满足 → 不安全
    return True, sequence


def request_resources(available, allocation, need, pid, request):
    """尝试为 pid 分配 request;返回 (是否批准, 说明)"""
    if any(request[j] > need[pid][j] for j in range(len(request))):
        return False, "请求超过声明的最大需求(Need),属于非法请求"
    if any(request[j] > available[j] for j in range(len(request))):
        return False, "当前可用资源不足,请求需排队等待"

    # 试探性分配
    for j in range(len(request)):
        available[j] -= request[j]
        allocation[pid][j] += request[j]        # 注意是二维:进程 pid 的第 j 类资源
        need[pid][j] -= request[j]

    safe, seq = is_safe(available, allocation, need)
    if safe:
        return True, f"批准,安全序列为 {['P' + str(i) for i in seq]}"

    # 回滚
    for j in range(len(request)):
        available[j] += request[j]
        allocation[pid][j] -= request[j]
        need[pid][j] += request[j]
    return False, "会导致系统进入不安全状态,请求被拒绝"


if __name__ == "__main__":
    # 教材经典例子:5 个进程、3 类资源 A/B/C
    available = [3, 3, 2]
    allocation = [[0, 1, 0], [2, 0, 0], [3, 0, 2], [2, 1, 1], [0, 0, 2]]
    need       = [[7, 4, 3], [1, 2, 2], [6, 0, 0], [0, 1, 1], [4, 3, 1]]

    safe, seq = is_safe(available, allocation, need)
    print("初始是否安全:", safe, "安全序列:", ["P" + str(i) for i in seq])
    # True,安全序列形如 ['P1', 'P3', 'P0', 'P2', 'P4']
    # (并列可满足时序列可能不同,但「安全」这个结论唯一)

    # 例 1:P0 请求 (0,0,2)。合法、资源也够,但分配后 Available=(3,3,0),
    # 除 P1 外没有任何进程的 Need 能被满足 → 不安全 → 拒绝
    print("P0 请求 (0,0,2):",
          request_resources(available, allocation, need, pid=0, request=[0, 0, 2]))
    print("  被拒绝后 Available 是否回滚:", available)
    # (False, '会导致系统进入不安全状态,请求被拒绝'),Available 仍是 [3, 3, 2]

    # 例 2:P1 请求 (1,0,2)。试探后 Available=(2,1,0),P1 之后 P3、P0 仍能依次完成 → 批准
    print("P1 请求 (1,0,2):",
          request_resources(available, allocation, need, pid=1, request=[1, 0, 2]))
    print("批准后 Available =", available, "P1 的 Allocation =", allocation[1])
    # (True, "批准,安全序列为 ['P1', 'P3', 'P0', 'P2', 'P4']")
    # Available 变为 [2, 3, 0],Allocation[1] 变为 [3, 0, 2]

    # 例 3:请求超过声明的 Need → 直接判定为非法,不做试探分配
    print("P3 请求 (1,1,1):",
          request_resources(available, allocation, need, pid=3, request=[1, 1, 1]))
    # (False, '请求超过声明的最大需求(Need),属于非法请求')

银行家算法的现实局限

它要求预先知道每个进程的最大资源需求,且进程之间互不通信、资源数量固定。

现实中(数据库锁、线程池、容器配额)这些条件几乎不成立,所以主流系统用的是

「超时 + 检测 + 杀进程」或「严格加锁顺序」的工程手段,而不是银行家算法。

九、内存管理

9.1 连续分配

方式说明问题
单一连续内存分系统区与用户区只支持单任务
固定分区预先切成若干块内部碎片(块内浪费)
动态分区按需切分外部碎片(小空洞无法利用)

动态分区的分配算法:首次适应(First Fit)、最佳适应(Best Fit,易产生小碎片)、最坏适应(Worst Fit)、临近适应(Next Fit)。可用紧凑(Compaction) 消除外部碎片,但需重定位支持。

9.2 分页、分段、段页式

对比项分页(Paging)分段(Segmentation)段页式(Segmented Paging)
划分依据物理等长(页)逻辑意义(代码/数据/栈)先按逻辑分段,段内再分页
地址页号 + 页内偏移段号 + 段内偏移段号 + 页号 + 页内偏移
大小固定(常见 4 KB)可变页固定、段可变
碎片只有内部碎片(最后一页)只有外部碎片内部碎片极小
对用户可见不可见(透明)可见(是逻辑单位)段可见,页不可见
共享与保护以页为单位,粒度细以段为单位,语义自然兼具两者
典型系统x86-64 主流模式早期 x86、部分嵌入式x86 传统模式、现代 OS 概念模型

地址转换:逻辑地址 → 页号 + 偏移 → 查页表得物理块号 → 物理地址 。

为什么要多级页表

32 位、4 KB 页、每页表项 4 B 时,单级页表有 项,占 4 MB —— 每个进程都要 4 MB 太浪费。

改成两级后,只有实际用到的二级页表才需要分配,未使用的地址区间不占内存。

x86-64 的 4 级页表(PML4 → PDPT → PD → PT)就是同一思路的延伸,详见 Intel SDM。

9.3 虚拟内存与缺页中断

虚拟内存(Virtual Memory) 让每个进程都以为自己独占一整块连续地址空间,实际数据按需在内存与磁盘之间搬运。

好处说明
容量扩展程序可以大于物理内存(按需调入)
隔离保护进程看不到彼此的内存,越界即段错误
共享共享库、fork 的写时复制(COW)
简化链接加载统一的地址假设,加载器不用重定位所有地址

缺页中断(Page Fault)处理流程:

  1. CPU 访问的页不在内存 → MMU 触发缺页异常,陷入内核;
  2. 内核检查地址合法性(非法 → SIGSEGV;合法但不在内存 → 继续);
  3. 在内存中找空闲页框;没有则按置换算法选一个牺牲页;
  4. 若牺牲页被修改过(脏位 D=1),先写回磁盘;
  5. 从磁盘读入所需页,更新页表,置有效位;
  6. 重新执行触发缺页的那条指令。

其中 为缺页率, 通常包含磁盘访问(毫秒级),比内存访问慢 5~6 个数量级。

缺页率必须极低

设内存访问 100 ns、缺页处理 10 ms,则

时 EAT ns,尚可接受;

时 EAT ,性能直接崩掉 100 倍。

这就是抖动(Thrashing):多道程序度过高,每个进程的驻留集都不够,疯狂换页。

9.4 页面置换算法与 Belady 异常

算法英文规则优点缺点
最佳置换OPT / MIN淘汰未来最久不用的页缺页率理论最低需要预知未来,无法实现(用作基准)
先进先出FIFO淘汰最早进入的页最简单有 Belady 异常,性能差
最近最久未使用LRU淘汰最久未访问的页接近 OPT,无 Belady 异常精确实现成本高(需链表/栈)
时钟Clock / NRU环形扫描,访问位为 0 就淘汰,为 1 则清零继续近似 LRU,开销小,实际最常用精度略低于 LRU

Belady 异常:增加页框数反而导致缺页次数增加——只有 FIFO 这类不满足栈性质(Stack Property)的算法才会出现,LRU 与 OPT 不会。

实测数据(用本节代码跑出来的真实结果)

引用串 A:7 0 1 2 0 3 0 4 2 3 0 3 2 1 2 0 1 7 0 1

| 算法 | 3 个页框 | 4 个页框 |

|---|---|---|

| FIFO | 15 次缺页 | 10 次缺页 |

| LRU | 12 次缺页 | 8 次缺页 |

| OPT | 9 次缺页 | 8 次缺页 |

| Clock | 14 次缺页 | 9 次缺页 |

引用串 B(Belady 异常的经典构造):1 2 3 4 1 2 5 1 2 3 4 5

| 算法 | 3 个页框 | 4 个页框 | 5 个页框 |

|---|---|---|---|

| FIFO | 9 次 | 10 次 ← 页框变多,缺页反而增加 | 5 次 |

| LRU | 10 次 | 8 次 | 5 次 |

由这两组数据可以得到两条关键结论:

① 比较算法必须在相同页框数下进行,跨页框数对比没有意义;

② LRU 之所以不会出现 Belady 异常,是因为它满足栈性质(Stack Property):

个页框的驻留集一定是 个页框驻留集的子集,因此缺页次数随页框数单调不增。

FIFO 不满足栈性质,所以它可以在页框增加时缺页反而变多。

"""page_replace.py —— FIFO / LRU / OPT / Clock 四种置换算法与 Belady 异常演示"""
from collections import deque, OrderedDict


def fifo(refs, frames):
    memq, faults = deque(), 0
    for r in refs:
        if r in memq:
            continue
        faults += 1
        if len(memq) == frames:
            memq.popleft()                      # 淘汰最早进入的
        memq.append(r)
    return faults


def lru(refs, frames):
    mem, faults = OrderedDict(), 0
    for r in refs:
        if r in mem:
            mem.move_to_end(r)                  # 命中:移到「最近使用」端
            continue
        faults += 1
        if len(mem) == frames:
            mem.popitem(last=False)             # 淘汰「最久未使用」端
        mem[r] = True
    return faults


def opt(refs, frames):
    mem, faults = set(), 0
    for i, r in enumerate(refs):
        if r in mem:
            continue
        faults += 1
        if len(mem) < frames:
            mem.add(r)
            continue
        # 选「下一次出现位置最靠后(或不再出现)」的页淘汰
        victim, farthest = None, -1
        for page in mem:
            try:
                nxt = refs.index(page, i + 1)
            except ValueError:
                nxt = float("inf")
            if nxt > farthest:
                victim, farthest = page, nxt
        mem.remove(victim)
        mem.add(r)
    return faults


def clock(refs, frames):
    """Clock(二次机会):环形缓冲 + 访问位,访问位为 1 则清零并跳过"""
    slots = [None] * frames
    use = [0] * frames
    hand, faults = 0, 0
    for r in refs:
        if r in slots:
            use[slots.index(r)] = 1             # 命中,给第二次机会
            continue
        faults += 1
        while use[hand] == 1:                   # 找访问位为 0 的槽位
            use[hand] = 0
            hand = (hand + 1) % frames
        slots[hand], use[hand] = r, 1
        hand = (hand + 1) % frames
    return faults


if __name__ == "__main__":
    refs = [7, 0, 1, 2, 0, 3, 0, 4, 2, 3, 0, 3, 2, 1, 2, 0, 1, 7, 0, 1]
    print(f"{'算法':<8}{'3 页框':>8}{'4 页框':>8}")
    for name, fn in (("FIFO", fifo), ("LRU", lru), ("OPT", opt), ("Clock", clock)):
        print(f"{name:<8}{fn(refs, 3):>8}{fn(refs, 4):>8}")
    # 实测输出(3 页框 / 4 页框):FIFO 15/10、LRU 12/8、OPT 9/8、Clock 14/9
    # 观察点:同一算法在 4 页框下的缺页数应尽量少;LRU / OPT 满足栈性质,一定单调不增

抖动(Thrashing)的识别与处理

症状:CPU 利用率不高,但磁盘 IO 满载,si/so(swap in/out)很高。

原因:多道程序度过高 / 内存不足,进程驻留集小于工作集。

处理:降低并发度、限制进程数、增大内存,或用工作集模型(Working Set)动态调整。

十、文件系统

10.1 inode 与文件元数据

inode(Index Node,索引节点) 存放除文件名外的全部元数据:

字段说明
文件类型与权限普通文件/目录/符号链接/设备;rwx 位、setuid/setgid/sticky
所有者UID、GID
大小字节数、占用块数(st_blocks,注意稀疏文件)
时间戳atime 访问、mtime 内容修改、ctime inode 变更
链接计数st_nlink,减到 0 才真正释放数据块
数据块指针直接指针 + 一级/二级/三级间接指针(ext 系列)

文件名不在 inode 里

目录本质是「文件名 → inode 号」的映射表。所以:

硬链接(Hard Link) 就是新增一条目录项指向同一个 inode,nlink 加一,删除一个名字数据仍在;

符号链接(Symbolic Link) 是另一个独立文件,内容是目标路径字符串,目标删掉就变成断链。

# 亲手验证硬链接与符号链接的差别
echo hello > /tmp/orig.txt
ln  /tmp/orig.txt /tmp/hard.txt        # 硬链接:共享 inode
ln -s /tmp/orig.txt /tmp/soft.txt      # 符号链接:新 inode,内容是路径
stat -c '%n inode=%i links=%h size=%s' /tmp/orig.txt /tmp/hard.txt /tmp/soft.txt
rm /tmp/orig.txt
cat /tmp/hard.txt                      # 仍能读到 hello(inode 未被释放)
cat /tmp/soft.txt                      # 报错:No such file or directory(断链)
ls -li /tmp/hard.txt /tmp/soft.txt

10.2 目录结构与文件系统类型

Linux 是树形目录 + 单一根,其他文件系统通过挂载(Mount) 接到树上。

目录内容(FHS 标准)
/根
/bin /usr/bin可执行文件(/bin 多为 /usr/bin 的链接)
/etc配置文件
/home用户家目录
/var可变数据:日志、缓存、数据库
/tmp临时文件(可能被清理或放在内存盘)
/proc /sys内核暴露的虚拟文件系统(不是磁盘上的数据)
/dev设备文件
/mnt /media挂载点

常见文件系统:ext4(通用默认)、XFS(大文件与高并发)、Btrfs/ZFS(快照与校验和)、NTFS/FAT32(Windows 兼容)、tmpfs(内存盘)、NFS/SMB(网络)。

10.3 磁盘调度

算法英文思路特点
先来先服务FCFS按请求顺序公平但寻道长
最短寻道优先SSTF优先服务最近的柱面平均寻道短,但远处请求饥饿
扫描SCAN(电梯)单方向扫到底再折返兼顾公平与效率
循环扫描C-SCAN只单向服务,回头不服务响应时间更均匀
LOOK / C-LOOK—扫到该方向最后一个请求就折返比 SCAN 少走空路

手算:请求队列 98, 183, 37, 122, 14, 124, 65, 67,磁头初始在 53,向磁道号增大方向移动

- FCFS:

- SSTF:53→65→67→37→14→98→122→124→183,总移动

- SCAN:53→65→67→98→122→124→183(到最右端)→ 折返 →37→14,总移动

- C-SCAN:只向一个方向服务,到端后直接跳回最小请求再继续,总移动 左右(取决于是否扫到端点)

现代磁盘调度另有其人

HDD 的固件内部已有复杂的重排序,Linux 的 mq-deadline、kyber、bfq 只是补充策略。

对 SSD 而言寻道概念消失(无机械臂),调度目标是减少写放大与保证公平,而不是减少寻道。

云环境里真正决定 IO 性能的往往是文件系统层(页缓存、预读)与块层队列深度。

十一、IO 模型

模型英文谁在等典型接口适用场景
阻塞 IOBlocking IO线程被挂起,直到数据就绪并拷贝完read()简单脚本、线程模型
非阻塞 IONon-blocking IO立即返回 EAGAIN,需轮询fcntl(O_NONBLOCK)轮询少量 fd
IO 多路复用IO Multiplexing一个线程等多个 fd 就绪select / poll / epoll高并发网络服务
信号驱动 IOSignal-driven IO内核 SIGIO 通知就绪O_ASYNC特殊场景,少用
异步 IOAsynchronous IO内核完成全部工作后通知Linux io_uring / aio高吞吐磁盘 IO、极致性能

同步 vs 异步的分界

判断标准是「数据从内核缓冲区拷贝到用户缓冲区这一步,谁来做」。

epoll 只告诉你「可以读了」,read() 仍由你自己调用(同步);io_uring 可以直接把数据放进你的缓冲区再通知你(异步)。

"""io_models.py —— 同一个「等两个 fd 就绪」的任务,三种写法对比"""
import select
import socket
import asyncio


def blocking_way(socks):
    """阻塞模型:两个连接要两个线程。这里顺序读,后一个会干等前一个"""
    for s in socks:
        data = s.recv(1024)                     # 阻塞在这里,直到有数据
        print("阻塞读到:", data)


def multiplexing_way(socks):
    """IO 多路复用:一个线程管理多个 fd,只在就绪时读"""
    poller = select.poll()
    for s in socks:
        poller.register(s, select.POLLIN)       # 告诉内核:有可读数据就通知我
    ready = dict(poller.poll(timeout=1000))     # 毫秒;返回 [(fd, 事件), ...]
    for s in socks:
        if ready.get(s.fileno(), 0) & select.POLLIN:
            print("就绪读到:", s.recv(1024))     # 这里有数据,recv 不会阻塞


async def async_way(reader, writer):
    """异步模型:await 让出控制权,事件循环去处理其他任务"""
    data = await reader.read(1024)              # 挂起当前协程,不阻塞线程
    print("异步读到:", data)
    writer.close()


def run_asyncio_server(host="127.0.0.1", port=8888):
    return asyncio.start_server(async_way, host, port)


if __name__ == "__main__":
    # 演示 epoll 的注册/等待流程(真实服务应使用 selectors 或 asyncio)
    srv = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    srv.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    srv.bind(("127.0.0.1", 0))                  # 端口 0:由内核分配空闲端口
    srv.listen(5)
    print("监听端口:", srv.getsockname()[1])

    # 触发一次就绪事件:自己连自己
    client = socket.create_connection(srv.getsockname())
    client.sendall(b"ping")
    conn, _ = srv.accept()
    multiplexing_way([conn])                    # 打印:就绪读到: b'ping'

    client.close()
    conn.close()
    srv.close()

11.1 select / poll / epoll 对比

对比项selectpollepoll
fd 上限通常 1024(FD_SETSIZE)无硬上限无硬上限
每次调用开销:每次都要拷入/拷出整个集合(注册一次,事件回调通知就绪的 fd)
数据结构位图数组内核红黑树 + 就绪链表
触发模式水平触发(LT)水平触发LT 与边缘触发(ET)
适用规模少量连接中等高并发(C10K/C10M)

边缘触发(ET)必须循环读到 EAGAIN

ET 模式只在状态变化时通知一次。若一次没读完内核缓冲区,剩余数据不会再触发通知,连接就「假死」了。

正确写法:while True: n = recv(...) 直到抛出 BlockingIOError。LT 模式则没读完会持续通知,容错更好但可能空转。

十二、Linux 常用命令实操

# ---------- 进程与调度 ----------
ps aux                          # 全量进程快照(%CPU、%MEM、STAT)
ps -eLf                         # 显示线程(LWP 列)
top -H -p 1234                  # 只看某进程的线程,按 H 切换线程视图
nice -n 10 ./cpu_hog &          # 以更低优先级(更大 nice 值)启动
renice -n -5 -p 1234            # 调整运行中进程的 nice 值(降低需权限)
taskset -c 0,1 ./app            # 绑定到 CPU 0 与 1,观察亲和性影响
kill -l                         # 列出所有信号
kill -TERM 1234                 # 优雅终止(进程可清理资源)
kill -KILL 1234                 # 强杀,无法被捕获,可能丢数据
pkill -f 'python.*worker'       # 按命令行模式批量终止

# ---------- 内存 ----------
free -h                         # 总览;重点看 available 而不是 free
vmstat 1 5                      # 每秒采样:si/so 非 0 说明在换页
cat /proc/meminfo | head -20    # 详细内存项(含 PageTables、Slab)
pmap -x 1234 | tail -5          # 某进程的内存映射明细
cat /proc/1234/smaps_rollup     # 进程内存汇总(RSS/PSS,PSS 适合算共享内存分摊)

# ---------- IO 与文件 ----------
iostat -xz 1                    # 磁盘:%util、await、aqu-sz
iotop -oP                       # 按进程看实时 IO(需 root)
lsof -p 1234                    # 进程打开的文件与网络连接
lsof +L1                        # 找出「已删除但仍被占用」的大文件(磁盘没释放的元凶)
du -sh * | sort -h | tail -10   # 找出当前目录下最大的子目录
df -hT                          # 各挂载点使用率与文件系统类型
find /var/log -type f -size +100M -exec ls -lh {} \;

# ---------- 追踪与诊断 ----------
strace -c -f ./app              # 系统调用耗时统计
strace -e trace=network -tt ./app
lsof -i :8080                   # 谁占用了 8080 端口
ss -s                           # 套接字统计
ss -tnp state established | head
perf top                        # 采样看热点函数(需权限)
dmesg -T | tail -50             # 内核日志:OOM Killer、IO 错误都在这里
journalctl -u myservice -n 100 --no-pager   # 某个 systemd 服务的日志
# 一个完整的排查流程示例:服务变慢,如何一步步定位
# 1) 看整体负载:r 列(运行队列长度)持续大于核数说明 CPU 竞争
uptime

# 2) 定位是 CPU、内存还是 IO 的问题
vmstat 1 5
#   si/so 高        -> 内存不足在换页
#   wa 高           -> IO 等待
#   us+sy 接近 100  -> CPU 瓶颈

# 3) 若是 CPU:找出是哪个进程、哪个线程、哪个函数
top -H -p $(pgrep -f myservice | head -1)
perf top -p $(pgrep -f myservice | head -1)

# 4) 若是 IO:确认是读还是写、多大块、谁在写
iostat -xz 1
iotop -oP

# 5) 若是内存:确认是泄漏还是缓存
cat /proc/$(pgrep -f myservice | head -1)/status | grep -E 'VmRSS|VmSwap'

十三、注意事项与常见坑

十五个高频错误

1. 忽略系统调用返回值。read 可能短读、write 可能返回 EINTR,健壮代码必须重试与循环。

2. 在信号处理函数里调用非异步信号安全的函数(如 printf、malloc)。信号处理里只应设置 volatile sig_atomic_t 标志,或调用 write。

3. fork 后在子进程里调用 printf 未刷新,导致输出重复——应用 _exit 而非 exit。

4. 有符号溢出当成回绕:C/C++ 中是有符号溢出是未定义行为,编译器可任意优化。

5. 用 if 检查条件变量:必须用 while 防虚假唤醒。

6. P/V 顺序写反导致死锁:先申请资源信号量,再申请互斥信号量。

7. 加锁顺序不一致:A 线程先锁 X 再锁 Y,B 线程反过来,必然死锁。

8. 持锁做耗时操作(IO、网络、日志落盘):临界区膨胀,吞吐骤降。

9. 忘了 waitpid 造成僵尸进程:子进程退出但 PCB 未回收,ps 里显示 <defunct>。

10. free 显示内存快满就慌了:Linux 会把空闲内存用作页缓存,应看 available 列。

11. /tmp 当持久存储:可能被 systemd 清理,或被挂成 tmpfs 随重启消失。

12. 删除文件后磁盘未释放:进程仍持有 fd,需 lsof +L1 找到并重启该进程。

13. 硬编码依赖 fd 编号:close(0) 后再 open 可能拿到 fd 0,引发离奇 bug。

14. 以为线程越多并发越高:线程切换、锁竞争、缓存失效会让性能反降;IO 密集适合异步,CPU 密集适合核数量级的线程数。

15. 在多线程程序中使用非线程安全函数(strtok、localtime、rand):应改 _r 版本或使用线程局部状态。

十四、练习题

基础题

1. 写出进程五状态模型的三条合法迁移与两条非法迁移,并解释为什么非法。

2. 用第六节的表数据(P1=5, P2=4, P3=1, P4=6,同时到达):

(a) 手算 FCFS 与 SJF 的平均等待时间;(b) 手算 RR()的执行序列与平均周转时间。

(答案:(a) FCFS 平均等待 6.0,SJF 平均等待 4.0,与第六节表格一致;

(b) 时执行序列为 P1(0-3) P2(3-6) P3(6-7, 完成) P4(7-10) P1(10-12, 完成) P2(12-13, 完成) P4(13-16, 完成),

周转时间分别为 P1=12、P2=13、P3=7、P4=16,平均周转 ;

对比 时的 15.5,可见时间片越大越接近 FCFS,越小时响应越好但周转变差)

3. 引用串 1 2 3 4 1 2 5 1 2 3 4 5,3 个页框,分别用 FIFO、LRU、OPT 求缺页次数。

(答案:FIFO = 9、LRU = 10、OPT = 7;可把引用串换成 7 0 1 2 0 3 0 4 2 3 0 3 2 1 2 0 1 7 0 1 再算一遍,

并验证 FIFO 在 4 个页框下的缺页次数)

进阶题

4. 系统有 3 类资源,Available = (1, 5, 2),各进程 Allocation / Need 如下。

判断当前是否安全(给出安全序列);若 P1 请求 (1, 0, 1),是否批准?

| 进程 | Allocation | Need |

|---|---|---|

| P0 | (0,1,0) | (0,0,0) |

| P1 | (1,0,0) | (1,0,1) |

| P2 | (1,0,1) | (1,0,1) |

| P3 | (0,1,1) | (0,1,1) |

(答案:先看 为零的 P0 —— 它的 恒可满足,完成后归还 ,

变为 ;同理 P2 的 可完成, 变为 ;

P3 的 可完成, 变为 ;最后 P1 的 可完成。

因此当前是安全状态,安全序列为 P0 → P2 → P3 → P1。

P1 请求 时:它不超过 ,也不超过 ,试探分配后 ,

但 P1 自己已全部满足( 归零)可立即完成,随后按 P1 → P0 → P2 → P3 仍能全部完成,

故可以批准)

5. 设内存访问 80 ns、缺页处理 8 ms。若要求有效访问时间不超过 100 ns,缺页率上限是多少?这个结论说明了什么?

(答案:由 解得 ,

即平均每 40 万次访问才允许缺页一次。结论:缺页率必须低到百万分之一量级,

一旦升到千分之一量级,有效访问时间就变成微秒级,性能下降上百倍——这就是抖动(Thrashing)的杀伤力)

6. 请求队列 82, 170, 43, 140, 24, 16, 190,磁头初始在 100 且向磁道号增大方向移动。

分别计算 FCFS、SSTF、SCAN、C-SCAN 的磁头移动总量,并说明哪个算法可能出现饥饿。

(答案:FCFS 、SSTF 、SCAN 、C-SCAN 。推导过程:

FCFS 按到达顺序 → ;

SSTF 的访问顺序为 → ;

SCAN 先向增大方向扫到 190 再折返到 16 → ;

C-SCAN 只向增大方向服务(到 190),然后直接跳回最小请求 16 → 。

SSTF 可能饥饿:只要持续有靠近当前磁头的请求到达,远端(如 190 附近)的请求就会被无限推迟;

SCAN 与 C-SCAN 因为会扫过整个方向上的所有请求,不会饿死任何请求)

思考题

7. 为什么 Linux 不用「最短作业优先」而用 CFS(完全公平调度)?从「服务器场景的目标函数」与「运行时间不可预知」两个角度回答。

(要点:① 服务器要优化的是吞吐量、尾延迟与公平性,而不是「最短平均周转时间」;

SJF 会让长任务无限等待(饥饿),而一台机器上既有毫秒级的请求处理、又有小时级的批处理任务,

饿死长任务是不可接受的。② SJF 需要预先知道每个任务的运行时间,这在通用操作系统上根本无法获得;

CFS 用 vruntime(虚拟运行时间,按权重折算的实际运行时间)近似「理想多任务处理器」,

无需任何预测信息就能保证长期公平,并让交互任务的延迟保持在可接受范围。

代价是它不追求理论最优的平均周转时间)

8. 你的服务在高并发下 CPU 使用率只有 30%,但 load average 达到 20(机器 4 核),vmstat 显示 wa 很高。

请给出至少三种可能的根因,以及对应的验证命令。

(要点:关键线索是「wa 高 + load 高但 CPU 不高」——load average 在 Linux 上包含处于不可中断睡眠(D 状态)的进程,

所以大量进程卡在 IO 上会让 load 飙升。三种可能根因:

① 内存不足在换页:验证 free -h 看 available、vmstat 1 看 si/so 是否为 0、cat /proc/<pid>/status | grep VmSwap;

② 磁盘本身成为瓶颈:验证 iostat -xz 1 看 %util 是否接近 100、await 是否远大于正常值,再用 iotop -oP 找出写盘最多的进程;

③ 锁或同步阻塞导致的 IO 等待(含存储后端慢、NFS 卡住):验证 cat /proc/<pid>/stack、lsof -p <pid> 看是否有异常挂载点,

或用 strace -f -T -p <pid> 看哪个系统调用耗时最长。

除此之外还要排查 dmesg -T | tail 是否出现磁盘 IO 错误或 OOM Killer 记录)

9. 容器(Docker)与虚拟机在「隔离机制」上的本质区别是什么?为什么容器里的 free 看到的还是宿主机的总内存?

(要点:容器是内核级的隔离——所有容器共享宿主机内核,靠 namespace 隔离视图

(pid/mnt/net/uts/ipc/user/cgroup),靠 cgroup 限制 CPU、内存等资源用量;

虚拟机是硬件级的隔离——由 Hypervisor 虚拟出 CPU/内存/设备,每个虚机跑自己独立的内核,

隔离更彻底(内核漏洞不直接穿透),代价是启动慢、内存开销大。

至于 free:它读的是 /proc/meminfo,而 /proc 是内核暴露的全局视图,并不按 cgroup 过滤,

所以容器里看到的是宿主机整机内存。要查看容器受到的真实限制,应读 cgroup 文件,

例如 cat /sys/fs/cgroup/memory.max(cgroup v2)或 memory.limit_in_bytes(cgroup v1),

以及 cat /sys/fs/cgroup/cpu.max。Java 程序在容器里若未开启 UseContainerSupport,

会按宿主机内存计算堆大小,正是这个原因导致的经典事故)

十五、常见问题 FAQ

Q1:线程一定比进程快吗?

不一定。创建和切换线程更快;但如果任务本质是 CPU 密集且需要频繁同步,线程间的锁竞争与伪共享会让性能反而不如多进程。

另外 Python 有 GIL,CPU 密集任务用线程几乎无法并行,应改多进程;参考 Python-07-进阶特性 中关于 GIL 的讨论。

选择依据:需要隔离 → 进程;IO 密集高并发 → 线程或异步;CPU 密集 → 进程/多核并行。

Q2:为什么要用虚拟内存,直接操作物理地址不行吗?

三个不可替代的好处:① 隔离:进程无法越界访问他人内存;② 简化:每个进程都从统一地址开始,链接加载不用考虑实际位置;③ 超售:总和大于物理内存的进程也能同时运行。

代价是 TLB 缺失时的多级页表查找,所以 CPU 用 TLB 缓存最近的映射。详见 计算机组成原理 的存储层次章节。

Q3:Optimal 置换算法不可能实现,那它有什么用?

它是最优性基准(Baseline)。评估一个实际算法好坏时,用「与 OPT 的缺页次数差距」来衡量,

例如 LRU 通常比 OPT 差 20%~30%,而 FIFO 可能差一倍。研究新算法时,OPT 是必报的对照组。

Q4:epoll 一定比 select 快吗?

在连接数很多但活跃连接很少时快得多,因为 epoll 只返回就绪的 fd,而 select 每次要遍历并拷贝整个集合。

但如果活跃用户占比很高(比如 80% 的 fd 每次都就绪),epoll 的 回调优势就不明显了,

瓶颈会转移到 read/write 本身。所以「上万连接」不是选 epoll 的充分理由,活跃比例才是关键。

Q5:怎么判断线上的一个「卡顿」是 CPU、内存还是 IO 引起的?

标准顺序:uptime 看趋势 → vmstat 1 5 分流(r 列大是 CPU 竞争,si/so 非 0 是换页,wa 高是 IO)→

按分流结果深入 top -H、iostat -xz、iotop。永远先看全局指标再定位到进程,跳过这一步容易查错方向。

Q6:学了操作系统原理,工作中能用上哪些具体东西?

最直接的五项:① 看懂 top/vmstat/iostat 的每一项;② 写出正确的并发代码(锁顺序、条件变量、原子性);

③ 排查「磁盘满了但删了文件没用」「进程卡死但 CPU 不高」这类经典问题;

④ 理解容器与虚拟机的隔离边界;⑤ 知道为什么网络服务要少用系统调用(批量、缓冲、io_uring)。

相关笔记

  • 计算机组成原理:中断、DMA、Cache 与 CPI 是本篇所有机制的硬件基础
  • 计算机网络:套接字、IO 多路复用与 TCP 缓冲在协议栈中的位置
  • Python-07-进阶特性:GIL 如何影响多线程与多进程的选择
  • CSharp-05-异步编程:async/await 与操作系统调度、线程池的配合方式
  • 数据库原理:事务隔离级别、锁与 MVCC 建立在进程同步与内存管理之上
  • 工具-02-命令行与Shell:本篇第十二节的命令在 Shell 中的进阶用法
  • 00-索引、学习路线图:全库导航与学习顺序

参考来源

  • Linux 系统调用总览 syscalls(2)(内核提供的全部系统调用):<https://man7.org/linux/man-pages/man2/syscalls.2.html>
  • pthreads(7) 手册页(线程、POSIX 同步原语文档):<https://man7.org/linux/man-pages/man7/pthreads.7.html>
  • epoll_wait(2) 手册页(LT/ET 触发模式与正确用法):<https://man7.org/linux/man-pages/man2/epoll_wait.2.html>
  • Linux 内核官方文档(调度器、内存管理、文件系统、块层):<https://www.kernel.org/doc/html/latest/>
  • Linux 内核调度器文档(CFS 与调度类的设计说明):<https://docs.kernel.org/scheduler/index.html>
  • POSIX.1-2024 标准(进程、线程、信号、文件接口的规范定义):<https://pubs.opengroup.org/onlinepubs/9799919799/>
  • Intel® 64 and IA-32 Architectures Software Developer's Manual(分页与特权级机制):<https://www.intel.com/content/www/us/en/developer/articles/technical/intel-sdm.html>
  • Silberschatz, Galvin & Gagne, Operating System Concepts(调度、同步、死锁、内存管理的经典教材依据)

版本提示

调度器实现(CFS 与 EEVDF)、页表级数、文件系统默认选项、内核参数默认值等随版本变化,

具体行为请以你所使用发行版与内核版本的官方最新文档为准(man 手册页与内核文档站点优先于二手教程)。