obsidian/操作系统/实验/实验03_多线程编程.md

# 实验03 Linux 多线程编程

## 实验目的

1. 掌握 POSIX 线程（pthread）的创建、等待和终止
2. 理解线程间共享地址空间的特性
3. 掌握信号量（semaphore）在线程同步中的使用
4. 理解竞态条件（race condition）的成因及修复方法
5. 学会使用生产者-消费者模型解决缓冲区同步问题
6. 了解并行计算中的加速比概念

## 涉及知识点

- `pthread_create` / `pthread_join` / `pthread_detach`
- POSIX 信号量：`sem_init` / `sem_wait`（P 操作） / `sem_post`（V 操作）
- 互斥锁（mutex）与信号量的区别
- 生产者-消费者问题
- 竞态条件与临界区保护
- 并行求和与加速比测量
- `fork` vs `pthread_create` 的开销对比

---

## 任务一：task61.c —— 三线程交替打印

### 任务要求

创建 3 个线程 T1、T2、T3，每个线程执行 5 次 `printf` 打印自己的线程 ID 和当前是第几次打印，每次打印后随机等待 1~5 秒。

### 关键代码提示

```c
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>
#include <time.h>

#define NUM_THREADS 3
#define PRINT_COUNT 5

void *thread_func(void *arg) {
    int id = *(int *)arg;
    for (int i = 0; i < PRINT_COUNT; i++) {
        printf("T%d: 第%d次打印 (PID=%d, TID=%lu)\n",
               id, i + 1, getpid(), (unsigned long)pthread_self());
        int wait_time = rand() % 5 + 1;   // 1~5 秒
        sleep(wait_time);
    }
    return NULL;
}

int main() {
    pthread_t threads[NUM_THREADS];
    int ids[NUM_THREADS];

    srand(time(NULL));

    for (int i = 0; i < NUM_THREADS; i++) {
        ids[i] = i + 1;
        pthread_create(&threads[i], NULL, thread_func, &ids[i]);
    }

    for (int i = 0; i < NUM_THREADS; i++)
        pthread_join(threads[i], NULL);

    printf("所有线程执行完毕\n");
    return 0;
}

// 编译：gcc -o task61 task61.c -lpthread
```

### 常见问题

| 问题 | 原因 | 解决方法 |
|------|------|----------|
| 输出交错混乱 | 多线程并发写 stdout | 正常现象，可用互斥锁保护 `printf` |
| 传参错误 | 循环变量地址被覆盖 | 使用数组存储各线程参数，而非循环变量地址 |
| 编译报错 undefined reference | 未链接 pthread | 加 `-lpthread` |

---

## 任务二：task62.c —— 用信号量修复竞态条件

### 任务要求

给定一个存在竞态条件的 `badcount.c` 程序（多线程同时对共享计数器自增），使用信号量修复该问题，使最终结果正确。

### 关键代码提示

```c
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <semaphore.h>

#define NTHREADS 4
#define NITERS   1000000

volatile long counter = 0;   // 共享计数器
sem_t mutex;                 // 信号量（用作互斥锁）

void *badcount(void *arg) {
    for (int i = 0; i < NITERS; i++) {
        sem_wait(&mutex);      // P 操作：进入临界区
        counter++;
        sem_post(&mutex);      // V 操作：离开临界区
    }
    return NULL;
}

int main() {
    pthread_t threads[NTHREADS];

    sem_init(&mutex, 0, 1);   // 初始值为 1，相当于互斥锁

    for (int i = 0; i < NTHREADS; i++)
        pthread_create(&threads[i], NULL, badcount, NULL);

    for (int i = 0; i < NTHREADS; i++)
        pthread_join(threads[i], NULL);

    printf("期望值: %d\n", NTHREADS * NITERS);
    printf("实际值: %ld\n", counter);
    printf("差值:   %ld\n",
           (long)(NTHREADS * NITERS) - counter);

    sem_destroy(&mutex);
    return 0;
}
```

### 修复原理

- 不加信号量时，`counter++` 不是原子操作（读-改-写三步），多线程交错执行导致丢失更新
- `sem_wait` / `sem_post` 将 `counter++` 包裹为临界区，保证同一时刻只有一个线程执行

### 常见问题

| 问题 | 原因 | 解决方法 |
|------|------|----------|
| 修复后差值仍不为 0 | 信号量使用错误 | 确保 `sem_wait`/`sem_post` 配对，且初始值为 1 |
| 程序死锁 | `sem_wait` 多次但 `sem_post` 不足 | 检查每个 `sem_wait` 是否有对应的 `sem_post` |
| 性能下降严重 | 信号量粒度太大 | 可尝试减小临界区范围 |

---

## 任务三：task63.c —— 生产者-消费者问题

### 任务要求

实现 k 个生产者线程和 m 个消费者线程，共享一个大小为 N 的环形缓冲区。生产者向缓冲区放入数据，消费者从缓冲区取出数据，使用信号量实现同步。

### 关键代码提示

```c
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <semaphore.h>

#define N      10    // 缓冲区大小
#define K      3     // 生产者数量
#define M      2     // 消费者数量
#define ITERS  20    // 每个生产者生产数量

int buffer[N];       // 环形缓冲区
int in = 0;          // 生产者写入位置
int out = 0;         // 消费者读取位置

sem_t mutex;         // 互斥访问缓冲区
sem_t slots;         // 空闲槽位数（初始 N）
sem_t items;         // 已有物品数（初始 0）

void *producer(void *arg) {
    int id = *(int *)arg;
    for (int i = 0; i < ITERS; i++) {
        int item = id * 100 + i;

        sem_wait(&slots);      // 等待空闲槽位
        sem_wait(&mutex);      // 进入临界区

        buffer[in] = item;
        printf("生产者%d: 放入 buffer[%d] = %d\n", id, in, item);
        in = (in + 1) % N;

        sem_post(&mutex);      // 离开临界区
        sem_post(&items);      // 增加物品计数
    }
    return NULL;
}

void *consumer(void *arg) {
    int id = *(int *)arg;
    int total = (K * ITERS) / M;   // 每个消费者消费数量
    for (int i = 0; i < total; i++) {
        sem_wait(&items);      // 等待物品
        sem_wait(&mutex);      // 进入临界区

        int item = buffer[out];
        printf("消费者%d: 取出 buffer[%d] = %d\n", id, out, item);
        out = (out + 1) % N;

        sem_post(&mutex);      // 离开临界区
        sem_post(&slots);      // 增加空闲槽位
    }
    return NULL;
}

int main() {
    pthread_t ptid[K], ctid[M];
    int pids[K], cids[M];

    sem_init(&mutex,  0, 1);
    sem_init(&slots,  0, N);
    sem_init(&items,  0, 0);

    for (int i = 0; i < K; i++) {
        pids[i] = i;
        pthread_create(&ptid[i], NULL, producer, &pids[i]);
    }
    for (int i = 0; i < M; i++) {
        cids[i] = i;
        pthread_create(&ctid[i], NULL, consumer, &cids[i]);
    }

    for (int i = 0; i < K; i++) pthread_join(ptid[i], NULL);
    for (int i = 0; i < M; i++) pthread_join(ctid[i], NULL);

    sem_destroy(&mutex);
    sem_destroy(&slots);
    sem_destroy(&items);

    printf("所有生产者和消费者完成\n");
    return 0;
}
```

### 信号量使用要点

| 信号量 | 初始值 | 含义 |
|--------|--------|------|
| `mutex` | 1 | 互斥锁，保护临界区 |
| `slots` | N | 空闲槽位数，生产者 P(slots)、消费者 V(slots) |
| `items` | 0 | 已有物品数，消费者 P(items)、生产者 V(items) |

**关键顺序：** P 操作时先 `P(slots/items)` 再 `P(mutex)`，否则可能死锁。

### 常见问题

| 问题 | 原因 | 解决方法 |
|------|------|----------|
| 死锁 | P 操作顺序不对 | 先 `P(slots)` 再 `P(mutex)` |
| 缓冲区越界 | 环形索引计算错误 | 使用 `% N` 取模 |
| 生产者/消费者数量不匹配 | 总生产量 != 总消费量 | 合理分配每个线程的生产/消费数量 |

---

## 任务四：task64.c —— 并行求和与加速比

### 任务要求

实现 `psum64.c`：将长度为 n 的数组分成若干段，每个线程计算一段的部分和，最后汇总得到总和。分别测试 1、2、4、8、16 个线程的执行时间，计算加速比。

### 关键代码提示

```c
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <sys/time.h>

#define MAXN 100000000   // 1 亿元素
#define MAX_THREADS 16

long a[MAXN];            // 全局数组
long psum[MAX_THREADS];  // 各线程的部分和
int n, num_threads;

void *sum_thread(void *arg) {
    int id = *(int *)arg;
    long chunk = n / num_threads;
    long start = id * chunk;
    long end = (id == num_threads - 1) ? n : start + chunk;

    psum[id] = 0;
    for (long i = start; i < end; i++)
        psum[id] += a[i];
    return NULL;
}

long get_time_us() {
    struct timeval tv;
    gettimeofday(&tv, NULL);
    return tv.tv_sec * 1000000L + tv.tv_usec;
}

int main() {
    n = MAXN;
    for (int i = 0; i < n; i++)
        a[i] = i + 1;   // 初始化数组

    int thread_counts[] = {1, 2, 4, 8, 16};
    long base_time = 0;

    for (int t = 0; t < 5; t++) {
        num_threads = thread_counts[t];
        pthread_t threads[MAX_THREADS];
        int ids[MAX_THREADS];

        long start = get_time_us();

        for (int i = 0; i < num_threads; i++) {
            ids[i] = i;
            pthread_create(&threads[i], NULL, sum_thread, &ids[i]);
        }
        for (int i = 0; i < num_threads; i++)
            pthread_join(threads[i], NULL);

        long total = 0;
        for (int i = 0; i < num_threads; i++)
            total += psum[i];

        long elapsed = get_time_us() - start;
        if (t == 0) base_time = elapsed;

        printf("线程数=%2d, 总和=%ld, 耗时=%ldus, 加速比=%.2f\n",
               num_threads, total, elapsed,
               (double)base_time / elapsed);
    }
    return 0;
}
```

### 常见问题

| 问题 | 原因 | 解决方法 |
|------|------|----------|
| 加速比不理想 | 线程创建开销、缓存竞争 | 正常现象，线程数超过核心数后收益递减 |
| 总和不对 | 分段边界计算错误 | 注意最后一段包含剩余元素 |
| 加速比超过线程数 | 计时误差 | 多次测量取平均值 |

---

## 任务五：task66.c —— fork 与 pthread_create 开销对比（选做）

### 任务要求

分别测量 `fork()` 和 `pthread_create()` 的执行时间，对比进程创建与线程创建的开销差异。

### 关键代码提示

```c
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
#include <sys/wait.h>
#include <sys/time.h>

#define N 10000

int main() {
    struct timeval start, end;

    // 测量 fork
    gettimeofday(&start, NULL);
    for (int i = 0; i < N; i++) {
        pid_t pid = fork();
        if (pid == 0) _exit(0);
        wait(NULL);
    }
    gettimeofday(&end, NULL);
    printf("fork x%d: %ld us (avg %.1f us)\n", N,
           end.tv_sec * 1000000L + end.tv_usec
           - start.tv_sec * 1000000L - start.tv_usec,
           (double)(end.tv_sec * 1000000L + end.tv_usec
           - start.tv_sec * 1000000L - start.tv_usec) / N);

    // 测量 pthread_create
    pthread_t tid;
    void *dummy(void *a) { return NULL; }

    gettimeofday(&start, NULL);
    for (int i = 0; i < N; i++) {
        pthread_create(&tid, NULL, dummy, NULL);
        pthread_join(tid, NULL);
    }
    gettimeofday(&end, NULL);
    printf("pthread_create x%d: %ld us (avg %.1f us)\n", N,
           end.tv_sec * 1000000L + end.tv_usec
           - start.tv_sec * 1000000L - start.tv_usec,
           (double)(end.tv_sec * 1000000L + end.tv_usec
           - start.tv_sec * 1000000L - start.tv_usec) / N);

    return 0;
}
```

---

## 任务六：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;

void sbuf_init(sbuf_t *sp, int n) {
    sp->buf = malloc(n * sizeof(int));
    sp->n = n;
    sp->front = sp->rear = 0;
    sem_init(&sp->mutex, 0, 1);
    sem_init(&sp->slots, 0, n);
    sem_init(&sp->items, 0, 0);
}

// 动态扩容：满时翻倍
void sbuf_insert(sbuf_t *sp, int item) {
    sem_wait(&sp->slots);
    sem_wait(&sp->mutex);

    sp->buf[sp->rear] = item;
    sp->rear = (sp->rear + 1) % sp->n;

    // 检查是否需要扩容（简化判断）
    // 实际实现需要更精细的逻辑

    sem_post(&sp->mutex);
    sem_post(&sp->items);
}

int sbuf_remove(sbuf_t *sp) {
    sem_wait(&sp->items);
    sem_wait(&sp->mutex);

    int item = sp->buf[sp->front];
    sp->front = (sp->front + 1) % sp->n;

    sem_post(&sp->mutex);
    sem_post(&sp->slots);
    return item;
}
```

---

## 实验总结

通过本实验，应掌握以下能力：

1. 使用 `pthread_create`/`pthread_join` 创建和管理线程
2. 使用 POSIX 信号量实现线程同步
3. 理解竞态条件的成因，学会用信号量/互斥锁保护临界区
4. 实现经典的生产者-消费者同步模型
5. 理解并行计算中的加速比及其限制因素
6. 了解 `fork` 与 `pthread_create` 的开销差异