引入线程的原因#

进程的内存空间由数据区、堆和栈组成。每创建一个进程，操作系统都要为它准备相互独立的内存结构：

进程切换时，操作系统需要保存当前执行状态，再恢复另一个进程的状态，这一过程称为上下文切换（$Context\ Switching$）。进程拥有独立的数据区和堆，创建、切换与通信的成本都相对较高。

若目的只是获得多条代码执行流，没有必要复制整个内存空间。线程只保留各自独立的栈，共享进程的数据区和堆：

这样做带来两个直接结果：

• 创建线程和切换线程通常比进程更快。
• 线程可以直接通过共享内存交换数据，不需要额外的$IPC$机制。

但共享也是多线程最需要谨慎处理的部分。多个线程能够访问同一变量，意味着它们也可能同时修改同一变量，并破坏数据的一致性。

进程与线程的关系#

进程是操作系统中构成独立执行流的单位，线程则是在进程内部构成独立执行流的单位。一个进程至少包含执行$main$函数的主线程，也可以继续创建其他线程：

线程不是脱离进程单独存在的资源。进程结束时，其内部线程也会一同终止；同一进程中的线程共享数据区、堆、打开的文件和套接字，但各自拥有独立的栈与执行位置。

创建线程#

1
#include <pthread.h>
2

3
int pthread_create(pthread_t *thread,
4
                   const pthread_attr_t *attr,
5
                   void *(*start_routine)(void *),
6
                   void *arg);
7
//成功时返回0，失败时返回其他值。

$thread$用于保存新线程的$ID$，$attr$用于指定线程属性，传入$NULL$表示使用默认属性。$start\_routine$是线程开始执行的函数，$arg$则是传给该函数的参数。线程函数的参数和返回值都使用$void *$，因此可以传递不同类型的数据地址。

1
void *thread_main(void *arg)
2
{
3
    int count = *((int *)arg);
4

5
    while (count--)
6
        puts("running thread");
7

8
    return NULL;
9
}
10

11
pthread_t thread_id;
12
int count = 5;
13

14
pthread_create(&thread_id, NULL,
15
               thread_main, (void *)&count);

调用$pthread\_create$后，主线程与新线程会沿不同执行流继续运行，具体调度顺序由操作系统决定：

若主线程通过$return$结束$main$函数，整个进程会终止，新线程也会被强制结束：

因此，不能依靠估算执行时间后调用$sleep$来等待线程。线程运行时间受系统调度与负载影响，固定等待时间过短会提前终止，过长则会造成无意义的停顿。

等待线程结束#

1
#include <pthread.h>
2

3
int pthread_join(pthread_t thread, void **status);
4
//成功时返回0，失败时返回其他值。

$pthread\_join$会阻塞调用它的线程，直到指定线程结束。若$status$不为$NULL$，还可以取得线程函数的返回值：

1
void *thread_return;
2

3
pthread_create(&thread_id, NULL,
4
               thread_main, (void *)&count);
5
pthread_join(thread_id, &thread_return);

这种等待是由线程状态驱动的，不依赖对运行时间的猜测。$pthread\_join$还会回收线程终止后保留的资源，因此适合既要等待结果、又要完成线程清理的场景。

线程安全函数#

函数中若存在多个线程同时执行时会引发问题的代码，该区域就是临界区。根据能否被多个线程安全地同时调用，函数可以分为：

• 线程安全函数（$Thread-safe\ function$）：多个线程同时调用也能保持正确结果。
• 非线程安全函数（$Thread-unsafe\ function$）：同时调用时可能相互干扰。

线程安全函数不代表内部没有临界区，而是函数已经通过同步、局部存储等方式保护了这些区域。部分$Linux$函数会提供名称以$\_r$结尾的可重入版本，例如$gethostbyname\_r$。

工作线程模型#

主线程负责分配任务，其他线程负责执行具体工作，这种结构称为工作线程模型（$Worker\ Thread\ Model$）。例如，可以让两个线程分别计算$1$至$5$与$6$至$10$的和，再由主线程等待并输出最终结果：

1
pthread_create(&id1, NULL, thread_summation, range1);
2
pthread_create(&id2, NULL, thread_summation, range2);
3

4
pthread_join(id1, NULL);
5
pthread_join(id2, NULL);
6

7
printf("result: %d\n", sum);

线程能够直接累加全局变量$sum$，正是因为它们共享数据区。不过，“能够访问”不等于“可以无条件同时修改”。这个简单示例的结果可能正确，但共享变量的读写仍然隐藏着竞态。

看似连续的操作并不原子#

$num += 1$在源代码中只有一条语句，但处理器执行时至少要经历“读取、计算、写回”三个步骤。理想情况下，线程$1$完整写回$100$后，线程$2$再读取并写回$101$：

问题在于，线程可能在任意指令之间被切换。线程$1$读取$99$并算出$100$，还没有写回内存时，执行权就可能转交给线程$2$：

线程$2$同样读取旧值$99$，完成运算后将$100$写入$num$：

随后线程$1$恢复运行，又把自己先前算出的$100$写回。两个线程各执行了一次加法，最终结果却只增加了$1$：

这种结果依赖线程执行时序的错误称为竞态条件（$Race\ Condition$）。它不要求两个线程在物理意义上同一时刻运行；只要两个操作的执行步骤交错，就可能出现。多核处理器只会让真正并行访问的机会更多。

临界区的位置#

临界区不是共享变量$num$本身，而是访问它并可能产生冲突的代码：

1
void *thread_inc(void *arg)
2
{
3
    num += 1;  //临界区
4
    return NULL;
5
}
6

7
void *thread_des(void *arg)
8
{
9
    num -= 1;  //同一组临界区
10
    return NULL;
11
}

临界区也不一定只由同一函数中的同一段代码构成。一个线程执行$num += 1$，另一个线程执行$num -= 1$，虽然语句与函数不同，但它们修改同一共享状态，仍然构成相互关联的临界区。

要避免竞态，需要保证某个线程进入临界区后，其他线程暂时不能进入相关临界区，直到前一个线程完成操作。这就是线程同步的一项核心任务。

使用互斥量保护临界区#

互斥量（$Mutex$）可以理解为一把锁。线程进入临界区前加锁，退出后解锁；若锁已被其他线程持有，当前线程会等待。

1
#include <pthread.h>
2

3
int pthread_mutex_init(pthread_mutex_t *mutex,
4
                       const pthread_mutexattr_t *attr);
5
int pthread_mutex_destroy(pthread_mutex_t *mutex);
6
int pthread_mutex_lock(pthread_mutex_t *mutex);
7
int pthread_mutex_unlock(pthread_mutex_t *mutex);
8
//成功时返回0，失败时返回其他值。

1
pthread_mutex_t mutex;
2

3
pthread_mutex_init(&mutex, NULL);
4

5
pthread_mutex_lock(&mutex);
6
num += 1;
7
pthread_mutex_unlock(&mutex);
8

9
pthread_mutex_destroy(&mutex);

$pthread\_mutex\_lock$返回后，当前线程已经取得锁；若锁被占用，它会阻塞到锁被释放。无论临界区正常结束还是发生错误，都必须保证执行$pthread\_mutex\_unlock$。遗漏解锁会让其他线程一直等待，形成死锁（$Deadlock$）。

确定加锁范围#

锁的范围会同时影响正确性与性能。只包围一条共享变量操作，可以缩短其他线程的等待时间，但循环中反复加锁、解锁会产生大量同步开销：

1
for (i = 0; i < 50000000; i++)
2
{
3
    pthread_mutex_lock(&mutex);
4
    num += 1;
5
    pthread_mutex_unlock(&mutex);
6
}

也可以把整个循环放进临界区，减少锁操作次数：

1
pthread_mutex_lock(&mutex);
2

3
for (i = 0; i < 50000000; i++)
4
    num += 1;
5

6
pthread_mutex_unlock(&mutex);

后一种方式更省锁操作，却会长时间阻止其他线程访问$num$。临界区既不能小到遗漏需要共同保护的状态，也不应无故扩大。实际范围应根据共享数据的一致性要求、锁竞争和操作耗时决定。

使用信号量控制执行顺序#

信号量（$Semaphore$）内部保存一个非负整数。$sem\_wait$尝试将其减$1$；若当前值为$0$，调用线程会阻塞。$sem\_post$将其加$1$，并可唤醒等待中的线程。

1
#include <semaphore.h>
2

3
int sem_init(sem_t *sem, int pshared,
4
             unsigned int value);
5
int sem_destroy(sem_t *sem);
6
int sem_wait(sem_t *sem);
7
int sem_post(sem_t *sem);
8
//成功时返回0，失败时返回其他值。

同一进程内的线程使用信号量时，$pshared$通常传入$0$，$value$指定初始值。只在$0$和$1$之间变化的信号量称为二进制信号量。

例如，一个线程读取用户输入，另一个线程负责累加。需要保证“写入新值”和“取走当前值”严格交替，可以使用两个信号量：

1
sem_t sem_ready;
2
sem_t sem_consumed;
3

4
sem_init(&sem_ready, 0, 0);
5
sem_init(&sem_consumed, 0, 1);

输入线程等待旧数据已被取走，再写入新值：

1
sem_wait(&sem_consumed);
2
scanf("%d", &num);
3
sem_post(&sem_ready);

累加线程等待新数据就绪，读取后允许下一次输入：

1
sem_wait(&sem_ready);
2
sum += num;
3
sem_post(&sem_consumed);

$sem\_ready$防止累加线程在数据写入前读取旧值，$sem\_consumed$防止输入线程在旧值取走前覆盖它。这里同步的重点不是互斥访问某段代码，而是建立两个线程之间的先后关系。

回收已经终止的线程#

线程函数返回后，线程虽然停止运行，但部分管理资源仍可能保留。应通过以下方式之一完成回收：

• 调用$pthread\_join$等待线程结束并回收资源。
• 调用$pthread\_detach$把线程设为分离状态，使其结束后自动回收资源。

1
#include <pthread.h>
2

3
int pthread_detach(pthread_t thread);
4
//成功时返回0，失败时返回其他值。

$pthread\_detach$不会终止线程，也不会等待线程结束。它只改变资源回收方式，因此适合服务器中创建后无需取得返回值的连接处理线程。线程一旦被分离，就不能再对它调用$pthread\_join$。

多线程聊天服务器的结构#

多线程并发服务器可以为每个客户端创建一个处理线程。主线程负责接受连接，工作线程负责读取对应客户端的消息，再把消息转发给所有已连接客户端：

1
while (1)
2
{
3
    clnt_sock = accept(serv_sock,
4
                       (struct sockaddr *)&clnt_adr,
5
                       &clnt_adr_sz);
6

7
    pthread_mutex_lock(&mutex);
8
    clnt_socks[clnt_cnt++] = clnt_sock;
9
    pthread_mutex_unlock(&mutex);
10

11
    pthread_create(&thread_id, NULL,
12
                   handle_clnt, (void *)&clnt_sock);
13
    pthread_detach(thread_id);
14
}

连接列表$clnt\_socks$和客户端数量$clnt\_cnt$会被主线程与多个工作线程共同访问，因此添加、删除和遍历客户端时都需要使用同一个互斥量保护：

1
void send_msg(char *msg, int len)
2
{
3
    int i;
4

5
    pthread_mutex_lock(&mutex);
6

7
    for (i = 0; i < clnt_cnt; i++)
8
        write(clnt_socks[i], msg, len);
9

10
    pthread_mutex_unlock(&mutex);
11
}

保护对象不是某个孤立变量，而是彼此共同描述连接状态的一组数据。若一个线程删除数组元素时，另一个线程正根据旧的$clnt\_cnt$遍历数组，就可能访问无效套接字；因此相关更新必须作为一个整体保持一致。

客户端也可以分别创建发送线程和接收线程。发送线程等待键盘输入并写入套接字，接收线程持续读取服务器消息。这样，即使接收操作正在等待网络数据，用户仍可继续输入；两个方向不必在同一条执行流中交替阻塞。

多线程模型让服务器的处理结构更加直观，但它并不会自动带来正确性。线程共享的连接表、计数器和业务状态都需要先明确所有权，再确定临界区与同步方式。只有在共享范围清晰的前提下，线程带来的低切换成本和直接数据交换才会真正成为优势。