模块 10: 操作系统

进程是带资源与地址空间上下文的运行程序。进程内线程共享内存，但有独立执行状态与栈。不同进程通常隔离普通内存，通信需管道、套接字或共享设施。进程可就绪、运行或因 I/O 阻塞。程序文件静态，同一文件可由多个进程执行。线程并发不代表 CPU 同时执行，解释器限制不同于系统保证。

调度器选择就绪工作。先来先服务简单，但长任务阻挡短任务。时间片轮转改善交互响应，片过小增加切换开销。周转为完成减到达，响应为首次服务减到达。保存恢复寄存器让切换后继续。公平、吞吐与延迟是不同目标，评估策略需负载与目标。

虚拟地址通过页映射转换到物理存储，页号选映射、偏移选页内字节。4096 字节页中地址 8197 为页二、偏移五。权限与独立映射隔离进程，TLB 缓存转换。缺页把控制交给系统，可分配、加载或拒绝，并非总读磁盘。虚拟内存是地址空间抽象，而非仅用磁盘增加 RAM。

文件提供有名字的持久数据，句柄跟踪打开实例与位置。用上下文管理器在异常后也可靠关闭。目录组织名字，权限管理操作。缓冲意味着写调用成功不一定已物理持久。抗崩溃更新需明确持久与原子策略。临时目录实验展示生命周期，而非持久数据库事务。

读改写可交错：双方读零、都写一，一次递增丢失。需同一锁保护整个临界区，而非仅最终写。常规 Python 的 GIL 不是应用事务保证。线程持有资源并循环等待其他资源可死锁，统一锁顺序有助避免。屏障实验强制特定顺序，无需依赖睡眠或随机机会。

下载脚本，在终端中使用 Python 3.11 或更新版本运行：python m10_process.py. Windows 也可使用 py -3；部分系统使用 python3。实验仅用标准库。先预测结果，再运行并完成变体。不要使用 -O，以保留断言。下方输出由构建器实际运行捕获，两种语言使用相同代码与输出。

检查子进程 ID 不同，输出不嵌入机器相关 ID。

下载 m10_process.py

"""Observe an isolated child process and scoped file cleanup."""
import json, os, subprocess, sys, tempfile
from pathlib import Path
child = subprocess.run([sys.executable, "-c", "import os,json; print(json.dumps({'pid':os.getpid(),'answer':6*7}))"],
                       check=True, capture_output=True, text=True, timeout=10)
data = json.loads(child.stdout)
assert data["pid"] != os.getpid() and data["answer"] == 42
print("child is a different process:", data["pid"] != os.getpid())
print("child result:", data["answer"])
with tempfile.TemporaryDirectory() as folder:
    path = Path(folder) / "catalogue.txt"
    path.write_text("Dune\nFoundation\n", encoding="utf-8")
    print("file records:", path.read_text(encoding="utf-8").splitlines())
print("temporary directory removed:", not Path(folder).exists())

child is a different process: True
child result: 42
file records: ['Dune', 'Foundation']
temporary directory removed: True

1. 让子进程非零退出。
2. 在调用者捕获 CalledProcessError。
3. 解释临时路径为何消失。

屏障确保双方写前都已读旧值，安全版本锁住完整更新。

下载 m10_race.py

"""Force a lost update deterministically, then protect a critical section."""
from threading import Barrier, Lock, Thread
counter, barrier = [0], Barrier(2)
def unsafe():
    old = counter[0]
    barrier.wait(timeout=5)  # both have read zero before either writes
    counter[0] = old + 1
threads = [Thread(target=unsafe) for _ in range(2)]
for t in threads: t.start()
for t in threads: t.join(timeout=10); assert not t.is_alive()
print("forced lost update:", counter[0])
assert counter[0] == 1

counter[0] = 0
lock = Lock()
def safe():
    for _ in range(1000):
        with lock:
            counter[0] = counter[0] + 1
threads = [Thread(target=safe) for _ in range(2)]
for t in threads: t.start()
for t in threads: t.join(timeout=10); assert not t.is_alive()
print("protected updates:", counter[0])
assert counter[0] == 2000

forced lost update: 1
protected updates: 2000

1. 画强制交错。
2. 把读取移到锁外，解释错误。
3. 解释屏障放进互斥锁为何阻碍推进。

先尝试，再展开解答。★ 应用概念；★★ 结合概念；★★★ 进行设计或证明。

选择答案查看反馈，重置后可重做。无需 JavaScript 也可阅读答案表。

• OSTEP 进程 — 阅读进程状态，区分就绪与运行。
• OSTEP 锁 — 跟踪丢失更新与保护版本。

解释屏障如何产生丢失更新，再说明锁保护的不变式。模块 11 将通过协议连接进程。