# 第07讲：多线程编程

> **本节目标**：理解线程的概念与优势，掌握 POSIX 线程 API（pthread），理解竞态条件的成因与解决方案（互斥锁、信号量），能够实现并行计算和生产者-消费者模型。

## 前置知识

- [[06_进程控制]] -- 进程的概念与创建
- [[08_进程间通信]] -- 进程间通信方式（与线程通信对比）

---

## 一、线程概念

### 1.1 什么是线程

**线程（Thread）** 是进程内的一个执行单元。一个进程可以包含多个线程，这些线程共享进程的地址空间，但每个线程拥有自己独立的栈和寄存器状态。

**生活比喻**：
- **进程** = 一家公司（独立的办公室、财务系统、人员编制）
- **线程** = 公司里的员工（共享办公室和财务系统，但各有各的工作任务）

### 1.2 进程 vs 线程

```mermaid
graph TB
    subgraph "多进程模型"
        P1["进程1"] --> M1["独立的地址空间"]
        P2["进程2"] --> M2["独立的地址空间"]
        M1 -.->|"IPC 通信<br/>(管道/共享内存)"| M2
    end

    subgraph "多线程模型"
        T1["线程1"] --> SM["共享的地址空间"]
        T2["线程2"] --> SM
        T3["线程3"] --> SM
        SM --> S1["代码段 (共享)"]
        SM --> S2["数据段 (共享)"]
        SM --> S3["堆 (共享)"]
        SM --> S4["栈 (各自独立)"]
    end

    style P1 fill:#e1f5fe
    style P2 fill:#e1f5fe
    style T1 fill:#e8f5e9
    style T2 fill:#e8f5e9
    style T3 fill:#e8f5e9
    style SM fill:#fff3e0
```

| 对比维度 | 进程 | 线程 |
|----------|------|------|
| 地址空间 | 独立（互不可见） | 共享（可见彼此的变量） |
| 创建开销 | 大（复制页表、地址空间） | 小（只创建栈和寄存器） |
| 切换开销 | 大（切换页表、刷新 TLB） | 小（只切换栈指针和寄存器） |
| 通信方式 | 需要 IPC 机制（管道、共享内存等） | 直接读写共享变量 |
| 安全性 | 高（地址空间隔离） | 低（需要同步机制保护） |
| 典型应用 | 独立的程序（如浏览器和音乐播放器） | 同一程序内的并发任务 |

### 1.3 线程的共享与私有

| 资源 | 共享/私有 | 说明 |
|------|-----------|------|
| 代码段 | 共享 | 所有线程执行相同的代码 |
| 数据段（全局变量） | 共享 | 所有线程可见同一份全局变量 |
| 堆（malloc 分配的内存） | 共享 | 任一线程分配的内存，其他线程可访问 |
| 栈 | **私有** | 每个线程有自己的栈，存放局部变量 |
| 寄存器状态 | **私有** | 每个线程有自己的程序计数器、栈指针等 |
| 信号处理 | 共享 | 信号发送给进程，任意线程可处理 |

---

## 二、POSIX 线程 API

### 2.1 核心函数

| 函数 | 作用 | 说明 |
|------|------|------|
| `pthread_create()` | 创建新线程 | 类似 `fork()`，但开销小得多 |
| `pthread_join()` | 等待线程结束 | 类似 `wait()`，阻塞调用线程 |
| `pthread_exit()` | 终止当前线程 | 类似 `exit()`，但只终止当前线程 |
| `pthread_self()` | 获取当前线程 ID | 类似 `getpid()` |
| `pthread_detach()` | 分离线程 | 线程结束后自动释放资源 |
| `pthread_cancel()` | 取消线程 | 请求终止另一个线程 |

### 2.2 pthread_create 详解

```c
int pthread_create(
    pthread_t *tid,              // 输出参数：新线程的 ID
    const pthread_attr_t *attr,  // 线程属性（通常传 NULL）
    void *(*start_routine)(void*), // 线程函数（新线程从这里开始执行）
    void *arg                    // 传递给线程函数的参数
);
// 返回值：成功返回 0，失败返回错误码
```

```mermaid
graph LR
    A["主线程调用<br/>pthread_create()"] --> B["操作系统创建新线程"]
    B --> C["新线程执行<br/>start_routine(arg)"]
    C --> D["线程函数返回"]
    D --> E["主线程调用<br/>pthread_join() 回收"]

    style A fill:#e1f5fe
    style C fill:#e8f5e9
    style E fill:#fff3e0
```

### 2.3 线程创建示例

参考 `实例源代码/chap6/pthread1.c`：

```c
#include "wrapper.h"
void *peertask(void *vargp);

int main()
{
    pthread_t tid;
    int i;

    pthread_create(&tid, NULL, peertask, NULL);  // 创建新线程

    for (i = 0; i < 2; i++) {
        printf("main thread looped %d times\n", i);
        usleep(10);
    }

    pthread_join(tid, NULL);  // 等待新线程结束
    exit(0);
}

void *peertask(void *vargp)  // 线程函数
{
    int i;
    for (i = 0; i < 4; i++) {
        printf("peer thread looped %d times\n", i);
        usleep(10);
    }
    return NULL;
}
```

**输出示例**（顺序不确定，因为主线程和新线程并发执行）：
```
main thread looped 0 times
peer thread looped 0 times
main thread looped 1 times
peer thread looped 1 times
peer thread looped 2 times
peer thread looped 3 times
```

**关键点**：
- `pthread_create` 创建新线程后，两个线程**并发执行**
- `pthread_join` 阻塞主线程，直到新线程结束
- 输出顺序取决于调度器，每次运行可能不同
- 编译时需要加 `-lpthread` 链接 pthread 库

---

## 三、线程安全问题 -- 竞态条件

### 3.1 什么是竞态条件

**竞态条件（Race Condition）** 是指多个线程同时访问和修改共享变量，最终结果取决于线程执行的精确时序，导致程序行为不可预测。

### 3.2 竞态条件演示

参考 `实例源代码/chap6/threadrace.c`：

```c
#include "wrapper.h"
#define N 4

void *thread(void *vargp);

int main()
{
    pthread_t tid[N];
    int i;

    for (i = 0; i < N; i++)
        pthread_create(&tid[i], NULL, thread, &i);  // 传递 i 的地址

    for (i = 0; i < N; i++)
        pthread_join(tid[i], NULL);
    exit(0);
}

void *thread(void *vargp)
{
    usleep(1);
    int myid = *((int *)vargp);  // 读取线程 ID
    printf("Hello from thread %d\n", myid);
    return NULL;
}
```

**问题分析**：所有线程共享同一个变量 `i` 的地址。当线程读取 `*vargp` 时，`i` 的值可能已经被主线程的循环修改了。

**可能出现的输出**：
```
Hello from thread 2
Hello from thread 2
Hello from thread 3
Hello from thread 3
```

### 3.3 竞态条件的时序分析

```mermaid
sequenceDiagram
    participant 主线程
    participant 线程0
    participant 线程1
    participant 线程2
    participant 线程3

    主线程->>线程0: pthread_create(&i)
    主线程->>主线程: i++ (i=1)
    主线程->>线程1: pthread_create(&i)
    主线程->>主线程: i++ (i=2)
    主线程->>线程2: pthread_create(&i)
    主线程->>主线程: i++ (i=3)
    主线程->>线程3: pthread_create(&i)

    Note over 线程0: 读取 *vargp，但 i 已经是 3
    Note over 线程1: 读取 *vargp，i 也是 3
    Note over 线程2: 读取 *vargp，i 也是 3
    Note over 线程3: 读取 *vargp，i 是 3

    线程0-->>主线程: Hello from thread 3 (错误!)
    线程1-->>主线程: Hello from thread 3 (错误!)
    线程2-->>主线程: Hello from thread 3 (错误!)
    线程3-->>主线程: Hello from thread 3
```

### 3.4 经典竞态：badcount.c

参考 `实例源代码/chap6/badcount.c`：

```c
#include "wrapper.h"
int count = 0;

void *increase(void *arg) {
    unsigned int i, niters = (unsigned int)arg;
    for (i = 0; i < niters; i++)
        count++;    // 非原子操作！
    return NULL;
}

void *decrease(void *arg) {
    unsigned int i, niters = (unsigned int)arg;
    for (i = 0; i < niters; i++)
        count--;    // 非原子操作！
    return NULL;
}

int main(int argc, char **argv) {
    unsigned int niters = atoll(argv[1]);
    pthread_t tid1, tid2;
    pthread_create(&tid1, NULL, increase, (void*)niters);
    pthread_create(&tid2, NULL, decrease, (void*)niters);
    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);

    if (count != 0)
        printf("Error! cnt=%d\n", count);  // 期望为0，但实际可能不为0
    else
        printf("Correct cnt=%d\n", count);
    exit(0);
}
```

**为什么 `count++` 和 `count--` 不是原子操作？**

```mermaid
graph LR
    subgraph "count++ 的三条指令"
        A1["LOAD count -> 寄存器"] --> A2["寄存器 = 寄存器 + 1"]
        A2 --> A3["STORE 寄存器 -> count"]
    end

    subgraph "count-- 的三条指令"
        B1["LOAD count -> 寄存器"] --> B2["寄存器 = 寄存器 - 1"]
        B2 --> B3["STORE 寄存器 -> count"]
    end

    style A1 fill:#e1f5fe
    style A2 fill:#fff3e0
    style A3 fill:#ffcdd2
    style B1 fill:#e1f5fe
    style B2 fill:#fff3e0
    style B3 fill:#ffcdd2
```

当两个线程的 LOAD/STORE 指令交错执行时，就会出现丢失更新的问题。

---

## 四、互斥锁（Mutex）

### 4.1 互斥锁的原理

互斥锁（Mutex）保证同一时刻只有一个线程可以进入**临界区**（访问共享资源的代码段）。其他试图获取已锁定的互斥锁的线程会被阻塞，直到锁被释放。

```mermaid
sequenceDiagram
    participant 线程1
    participant 互斥锁
    participant 线程2
    participant 共享变量

    线程1->>互斥锁: pthread_mutex_lock()
    Note over 互斥锁: 锁状态：已锁定
    线程1->>共享变量: 读取 count (0)

    线程2->>互斥锁: pthread_mutex_lock()
    Note over 互斥锁: 锁已被占用，线程2 阻塞

    线程1->>共享变量: count = count + 1 = 1
    线程1->>互斥锁: pthread_mutex_unlock()
    Note over 互斥锁: 锁状态：已解锁
    互斥锁-->>线程2: 被唤醒，获得锁

    线程2->>共享变量: 读取 count (1)
    线程2->>共享变量: count = count - 1 = 0
    线程2->>互斥锁: pthread_mutex_unlock()

    Note over 共享变量: count = 0 (正确!)
```

### 4.2 互斥锁 API

| 函数 | 作用 |
|------|------|
| `pthread_mutex_init()` | 初始化互斥锁 |
| `pthread_mutex_lock()` | 加锁（阻塞等待） |
| `pthread_mutex_trylock()` | 尝试加锁（非阻塞） |
| `pthread_mutex_unlock()` | 解锁 |
| `pthread_mutex_destroy()` | 销毁互斥锁 |

**初始化方式**：
```c
// 方式1：静态初始化
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

// 方式2：动态初始化
pthread_mutex_t mutex;
pthread_mutex_init(&mutex, NULL);
```

### 4.3 互斥锁修复竞态

参考 `实例源代码/chap6/mutex1.c`：

```c
// mutex1.c - 使用互斥锁保护共享变量
#include "wrapper.h"
int count = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

void *thread_fun(void *no) {
    pthread_mutex_lock(&mutex);     // 加锁 -- 进入临界区
    count++;
    printf("thread %d, count = %d\n", (int)no, count);
    pthread_mutex_unlock(&mutex);   // 解锁 -- 离开临界区
}

int main() {
    pthread_t thread_id1, thread_id2;
    Pthread_create(&thread_id1, NULL, thread_fun, (void*)1);
    Pthread_create(&thread_id2, NULL, thread_fun, (void*)2);
    Pthread_join(thread_id1, NULL);
    Pthread_join(thread_id2, NULL);
    Pthread_exit(0);
}
```

**输出**（保证正确）：
```
thread 1, count = 1
thread 2, count = 2
```

### 4.4 另一种修复方式：避免共享

参考 `实例源代码/chap6/norace.c`，通过为每个线程分配独立的内存来避免共享：

```c
// norace.c - 使用动态分配避免竞态
for (i = 0; i < N; i++) {
    ptr = malloc(sizeof(int));  // 为每个线程分配独立的内存
    *ptr = i;
    pthread_create(&tid[i], NULL, thread, ptr);
}
```

**原理**：每个线程拥有自己独立的 `int` 变量，不再共享 `i`，从根本上消除了竞态条件。

---

## 五、信号量（Semaphore）

### 5.1 信号量的概念

信号量是一种比互斥锁更通用的同步机制，由 Dijkstra 提出。信号量是一个非负整数计数器，支持两个原子操作：

- **P 操作**（`sem_wait`）：计数器减 1，如果计数器 < 0 则阻塞
- **V 操作**（`sem_post`）：计数器加 1，如果有等待者则唤醒

```mermaid
graph LR
    subgraph "信号量 S"
        S["S = 计数器"]
    end

    P["sem_wait (P操作)<br/>S--"] -->|S >= 0| OK["允许通过"]
    P -->|S < 0| BLOCK["阻塞等待"]

    V["sem_post (V操作)<br/>S++"] --> WAKE["唤醒等待者"]

    style S fill:#fff3e0
    style OK fill:#e8f5e9
    style BLOCK fill:#ffcdd2
```

### 5.2 信号量 API

| 函数 | 作用 |
|------|------|
| `sem_init(&sem, pshared, value)` | 初始化信号量，value 为初始值 |
| `sem_wait(&sem)` | P 操作：等待信号量（S--，若 S<0 则阻塞） |
| `sem_post(&sem)` | V 操作：释放信号量（S++，唤醒等待者） |
| `sem_getvalue(&sem, &val)` | 获取信号量当前值 |
| `sem_destroy(&sem)` | 销毁信号量 |

### 5.3 互斥锁 vs 信号量

| 特性 | 互斥锁 (Mutex) | 信号量 (Semaphore) |
|------|----------------|-------------------|
| 计数范围 | 0 或 1（二值） | 0 到 N（计数） |
| 用途 | 互斥（保护临界区） | 同步（协调执行顺序） |
| 加锁/解锁者 | 谁加锁谁解锁 | 一个线程 sem_wait，另一个 sem_post |
| 典型场景 | 保护共享变量 | 生产者-消费者、资源池 |

### 5.4 生产者-消费者问题

生产者-消费者是经典的同步问题：生产者向缓冲区放入数据，消费者从缓冲区取出数据。需要解决：
- 缓冲区满时生产者必须等待
- 缓冲区空时消费者必须等待
- 同一时刻只有一个线程访问缓冲区

**使用信号量解决**：

```c
#include <semaphore.h>

#define N 10  // 缓冲区大小
int buf[N];
int in = 0, out = 0;

sem_t mutex;  // 互斥信号量，初值 1
sem_t empty;  // 空槽位数，初值 N
sem_t full;   // 满槽位数，初值 0

void *producer(void *arg) {
    while (1) {
        int item = produce_item();
        sem_wait(&empty);   // 等待空槽位 (empty--)
        sem_wait(&mutex);   // 进入临界区
        buf[in] = item;
        in = (in + 1) % N;
        sem_post(&mutex);   // 离开临界区
        sem_post(&full);    // 增加满槽位 (full++)
    }
}

void *consumer(void *arg) {
    while (1) {
        sem_wait(&full);    // 等待满槽位 (full--)
        sem_wait(&mutex);   // 进入临界区
        int item = buf[out];
        out = (out + 1) % N;
        sem_post(&mutex);   // 离开临界区
        sem_post(&empty);   // 增加空槽位 (empty++)
        consume_item(item);
    }
}
```

**生产者-消费者流程图**：

```mermaid
graph TD
    subgraph "生产者"
        P1["生产数据"] --> P2["sem_wait(empty)<br/>等待空槽位"]
        P2 --> P3["sem_wait(mutex)<br/>进入临界区"]
        P3 --> P4["放入缓冲区"]
        P4 --> P5["sem_post(mutex)<br/>离开临界区"]
        P5 --> P6["sem_post(full)<br/>通知消费者"]
        P6 --> P1
    end

    subgraph "消费者"
        C1["sem_wait(full)<br/>等待满槽位"] --> C2["sem_wait(mutex)<br/>进入临界区"]
        C2 --> C3["取出数据"]
        C3 --> C4["sem_post(mutex)<br/>离开临界区"]
        C4 --> C5["sem_post(empty)<br/>通知生产者"]
        C5 --> C6["处理数据"]
        C6 --> C1
    end

    P6 -.->|"full++ 唤醒"| C1
    C5 -.->|"empty++ 唤醒"| P2

    style P1 fill:#e1f5fe
    style C6 fill:#e8f5e9
```

### 5.5 实验任务：修复 badcount.c

实验中的 `task62.c` 要求使用信号量修复 `badcount.c` 的竞态条件：

```c
#include <semaphore.h>
sem_t mutex;
sem_init(&mutex, 0, 1);  // 互斥信号量，初值 1

void *increase(void *arg) {
    for (i = 0; i < niters; i++) {
        sem_wait(&mutex);    // P 操作
        count++;
        sem_post(&mutex);    // V 操作
    }
}

void *decrease(void *arg) {
    for (i = 0; i < niters; i++) {
        sem_wait(&mutex);    // P 操作
        count--;
        sem_post(&mutex);    // V 操作
    }
}
```

---

## 六、并行计算

### 6.1 并行求和问题

参考 `实例源代码/chap6/psum64.c`，将一个大数组的求和任务分配给多个线程并行计算：

```c
#include "wrapper.h"
#define MAXTHREADS 32

unsigned long long psum[MAXTHREADS];  // 每个线程的部分和
unsigned long long nelems_per_thread; // 每个线程处理的元素数

void *sum(void *vargp) {
    int myid = *((int *)vargp);
    unsigned long long start = myid * nelems_per_thread;
    unsigned long long end = start + nelems_per_thread;
    unsigned long long i, lsum = 0;

    for (i = start; i < end; i++)
        lsum += i;

    psum[myid] = lsum;  // 将部分和存入全局数组
    return NULL;
}

int main(int argc, char **argv) {
    unsigned long long i, nelems, nthreads, result = 0;
    pthread_t tid[MAXTHREADS];
    int myid[MAXTHREADS];

    nthreads = atoi(argv[1]);
    nelems = (1L << atoi(argv[2]));  // 2^log_nelems
    nelems_per_thread = nelems / nthreads;

    // 创建线程
    for (i = 0; i < nthreads; i++) {
        myid[i] = i;
        pthread_create(&tid[i], NULL, sum, &myid[i]);
    }
    for (i = 0; i < nthreads; i++)
        pthread_join(tid[i], NULL);

    // 汇总部分和
    for (i = 0; i < nthreads; i++)
        result += psum[i];

    // 验证结果
    if (result == (nelems * (nelems - 1) / 2))
        printf("Correct Result=%lld\n", result);
    else
        printf("Error: result=%lld\n", result);

    exit(0);
}
```

**并行求和示意图**：

```mermaid
graph TD
    subgraph "数据划分"
        DATA["0, 1, 2, 3, 4, 5, 6, 7, ..."]
        DATA --> T0["线程0: 0 ~ N/p-1"]
        DATA --> T1["线程1: N/p ~ 2N/p-1"]
        DATA --> T2["线程2: 2N/p ~ 3N/p-1"]
        DATA --> T3["线程3: 3N/p ~ N-1"]
    end

    T0 --> S0["psum[0]"]
    T1 --> S1["psum[1]"]
    T2 --> S2["psum[2]"]
    T3 --> S3["psum[3]"]

    S0 --> SUM["result = psum[0]+psum[1]+psum[2]+psum[3]"]
    S1 --> SUM
    S2 --> SUM
    S3 --> SUM

    style DATA fill:#e1f5fe
    style SUM fill:#e8f5e9
```

### 6.2 加速比与效率

**加速比（Speedup）**：S_p = T_1 / T_p
- T_1：单线程执行时间
- T_p：p 个线程并行执行时间
- 理想加速比 S_p = p（线性加速）

**效率（Efficiency）**：E_p = S_p / p = T_1 / (p * T_p)
- 理想效率 E_p = 1（100%）
- 实际效率 < 1，因为存在线程创建、同步、通信等开销

```mermaid
graph LR
    subgraph "加速比曲线"
        X["线程数 p"] --> Y["加速比 Sp"]
        IDEAL["理想: Sp=p"] -.-> Y
        ACTUAL["实际: Sp<p"] --> Y
    end
```

### 6.3 实验任务：测量加速比

实验中的 `task64.c` 要求：
1. 修改 `psum64.c`，添加计时功能
2. 分别用 1、2、4、8 个线程运行
3. 计算每个配置的加速比和效率
4. 分析为什么加速比不是线性的

**预期结果**：

| 线程数 | 执行时间 | 加速比 | 效率 |
|:------:|:--------:|:------:|:----:|
| 1 | T1 | 1.0 | 100% |
| 2 | T2 | ~1.8 | ~90% |
| 4 | T4 | ~3.2 | ~80% |
| 8 | T8 | ~5.5 | ~69% |

---

## 七、fork vs pthread_create 性能对比

### 7.1 为什么线程更快

`fork()` 创建进程时需要复制父进程的整个地址空间（虽然有写时复制优化），而 `pthread_create()` 只需要分配一个新的栈和少量元数据。

```mermaid
graph LR
    subgraph "fork() 创建进程"
        F1["复制页表"] --> F2["复制地址空间<br/>(写时复制)"]
        F2 --> F3["创建新的 PCB"]
        F3 --> F4["开销大: ~ms 级"]
    end

    subgraph "pthread_create() 创建线程"
        T1["分配栈空间"] --> T2["设置线程属性"]
        T2 --> T3["创建线程元数据"]
        T3 --> T4["开销小: ~us 级"]
    end

    style F4 fill:#ffcdd2
    style T4 fill:#e8f5e9
```

### 7.2 实验任务：测量创建时间

实验中的 `task66.c` 要求分别测量 `fork()` 和 `pthread_create()` 的创建时间：

```c
// 测量 fork 创建时间
clock_gettime(CLOCK_MONOTONIC, &start);
for (i = 0; i < N; i++) {
    if (fork() == 0) exit(0);  // 子进程立即退出
    wait(NULL);
}
clock_gettime(CLOCK_MONOTONIC, &end);

// 测量 pthread_create 创建时间
clock_gettime(CLOCK_MONOTONIC, &start);
for (i = 0; i < N; i++) {
    pthread_create(&tid, NULL, dummy, NULL);
    pthread_join(tid, NULL);
}
clock_gettime(CLOCK_MONOTONIC, &end);
```

**预期结果**：`pthread_create` 通常比 `fork` 快 10-100 倍。

---

## 八、动态线程池

### 8.1 为什么需要线程池

频繁创建和销毁线程会带来较大开销。线程池预先创建一组线程，当有任务到来时从池中取出一个线程执行，执行完毕后线程归还池中，避免反复创建销毁。

### 8.2 sbuf_t 带缓冲区的线程池

实验中的 `task67.c` 实现了一个动态线程池，核心数据结构 `sbuf_t`：

```c
typedef struct {
    int *buf;       // 缓冲区数组
    int n;          // 缓冲区容量
    int front;      // 队首索引
    int rear;       // 队尾索引
    sem_t mutex;    // 互斥访问
    sem_t slots;    // 空槽位信号量
    sem_t items;    // 满槽位信号量
} sbuf_t;
```

**动态调整策略**：
- **缓冲区满时翻倍**：`buf = realloc(buf, 2 * n)`
- **缓冲区空时减半**：`buf = realloc(buf, n / 2)`

```mermaid
graph TD
    subgraph "线程池架构"
        MAIN["主线程<br/>接收任务"] -->|"放入缓冲区"| BUF["sbuf_t 缓冲区"]
        BUF -->|"取出任务"| W1["工作线程1"]
        BUF -->|"取出任务"| W2["工作线程2"]
        BUF -->|"取出任务"| W3["工作线程3"]
    end

    subgraph "动态调整"
        FULL["缓冲区满"] -->|"realloc"| DOUBLE["容量翻倍"]
        EMPTY["缓冲区空"] -->|"realloc"| HALF["容量减半"]
    end

    style MAIN fill:#e1f5fe
    style BUF fill:#fff3e0
    style W1 fill:#e8f5e9
    style W2 fill:#e8f5e9
    style W3 fill:#e8f5e9
```

---

## 九、线程安全的数据结构

### 9.1 tickets 售票问题

参考 `实例源代码/chap6/tickets1.c`（有竞态条件）和 `tickets2.c`（使用互斥锁修复）：

```c
// tickets2.c - 使用互斥锁保护售票
int tickets = 10;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

void *counter(void *no) {
    while (tickets > 0) {
        pthread_mutex_lock(&mutex);      // 加锁
        if (tickets > 0) {               // 双重检查
            printf("柜台%d 卖出一张票，票号为%d\n", (int)no, tickets);
            usleep(1);
            tickets--;
        }
        pthread_mutex_unlock(&mutex);    // 解锁
        usleep(1);
    }
}
```

**关键点**：`while` 条件检查和 `if` 条件检查都需要在锁内进行（双重检查），否则可能出现超卖。

---

## 十、实验任务概览

本讲对应 [[实验03_多线程编程]]，包含以下任务：

| 任务 | 文件 | 内容 | 核心知识点 |
|------|------|------|------------|
| 任务一 | task61.c | 3 个对等线程打印姓名/学号/时间 | pthread_create/join |
| 任务二 | task62.c | 用信号量修复 badcount.c 的竞态条件 | sem_wait/sem_post |
| 任务三 | task63.c | k 个生产者 + m 个消费者，信号量同步 | 生产者-消费者模型 |
| 任务四 | task64.c | psum64.c 并行求和，测量不同线程数的加速比 | 并行计算 + 性能分析 |
| 任务五 | task66.c | 测量 fork vs pthread_create 时间 | 进程/线程创建开销对比 |
| 任务六 | task67.c | 动态线程池（sbuf_t 缓冲区满翻倍/空减半） | 线程池 + 动态数据结构 |

---

## 知识关联

- 线程是轻量级进程，理解 [[06_进程控制]] 中的 fork 有助于理解线程的优势
- 线程间的同步问题在死锁章节中会进一步讨论
- 生产者-消费者模型在 [[08_进程间通信]] 中也有管道和共享内存的实现方式
- 线程池在并发网络服务器中是核心组件

---

## 思考题

1. **互斥锁 vs 信号量**：互斥锁和二值信号量（初值为 1 的信号量）看起来功能相同，它们有什么本质区别？什么时候必须用信号量而不能用互斥锁？
2. **死锁的产生**：如果一个线程对已经加锁的互斥锁再次调用 `pthread_mutex_lock()`，会发生什么？如果两个线程分别持有对方需要的锁呢？
3. **线程安全的函数**：为什么 `printf()` 是线程安全的，而 `count++` 不是？如何判断一个函数是否线程安全？
4. **并行计算的瓶颈**：为什么 p 个线程的加速比通常达不到理想的 p 倍？哪些因素限制了并行加速？
5. **fork vs pthread**：在什么场景下应该用多进程而不是多线程？多进程模型有什么优势？

---

## 扩展阅读

- 《UNIX环境高级编程》第11章：线程
- 《深入理解计算机系统》第12章：并发编程
- 《POSIX 多线程编程指南》
- [Pthreads Tutorial (LLNL)](https://computing.llnl.gov/tutorials/pthreads/)