C语言中的多线程编程：pthread的使用与注意事项

多线程编程是现代软件开发中不可或缺的一部分，它允许程序同时执行多个任务，从而提高效率和响应速度。在C语言中，`pthread`库是实现多线程编程的标准接口。本文将通过讲故事的方式，深入探讨`pthread`的使用方法以及多线程编程中需要注意的关键问题，帮助你编写高效、可靠的多线程程序。

一、多线程编程的基础知识

1. 什么是多线程？

多线程（Multithreading）是指在一个进程中同时执行多个线程的能力。每个线程都有自己的执行路径，但共享进程的资源，如内存空间和文件句柄。多线程编程可以显著提高程序的性能，尤其是在处理I/O密集型任务时。

2. 多线程的优势

提高程序响应速度：在图形界面程序中，主线程负责处理用户输入，而其他线程负责执行后台任务，从而避免界面卡顿。
充分利用多核处理器：现代处理器通常具有多个核心，多线程可以将任务分配到不同的核心上，提高计算效率。
简化程序设计：将复杂的任务分解为多个线程，使程序结构更加清晰和易于维护。

示例验证：多线程的优势

#include <stdio.h>       // 包含标准输入输出函数头文件，用于printf等函数
#include <stdlib.h>      // 包含标准库函数头文件，用于内存分配等操作
#include <pthread.h>     // 包含POSIX线程库头文件，用于多线程操作
#include <unistd.h>      // 包含UNIX标准库头文件，用于sleep等系统调用// 定义线程函数，参数类型为void指针以支持任意数据类型传递
void* thread_function(void* arg) {int thread_id = *(int*)arg;  // 将void指针参数转换为int指针，并解引用获取线程IDprintf("线程 %d 开始执行\n", thread_id);  // 打印线程启动信息sleep(1);                    // 使当前线程休眠1秒，模拟实际任务执行时间printf("线程 %d 执行完成\n", thread_id);  // 打印线程完成信息return NULL;                 // 线程函数返回空指针（线程退出）
}// 主函数入口
int main() {printf("主线程开始执行\n");  // 主线程打印启动信息pthread_t threads[2];        // 声明pthread_t类型数组，用于存储两个线程标识符int thread_ids[2] = {1, 2};  // 声明并初始化线程ID数组，自定义线程编号// 循环创建两个工作线程for (int i = 0; i < 2; i++) {  // i为循环计数器，控制创建线程的数量// 创建新线程，参数依次为：线程标识符指针、线程属性（NULL为默认）、线程函数、传递给函数的参数pthread_create(&threads[i], NULL, thread_function, &thread_ids[i]);}// 循环等待所有线程执行完毕（线程同步）for (int i = 0; i < 2; i++) {  // i为循环计数器，控制等待线程的数量pthread_join(threads[i], NULL);  // 阻塞主线程，直到指定线程执行完毕}printf("主线程执行完成\n");  // 所有子线程结束后打印主线程结束信息return 0;                   // 主函数返回0，表示程序正常退出
}

问题验证：

什么是多线程？
多线程有哪些优势？

二、pthread的基本使用

1. pthread的基本函数

C语言中的pthread库提供了许多函数用于创建和管理线程。以下是一些常用的函数：

pthread_create：创建一个新线程。
pthread_join：等待一个线程完成。
pthread_exit：终止当前线程。
pthread_mutex_t：用于线程同步的互斥锁。

示例验证：pthread的基本使用

#include <stdio.h>       // 包含标准输入输出函数头文件，用于printf等函数
#include <stdlib.h>      // 包含标准库函数头文件，用于内存分配等操作
#include <pthread.h>     // 包含POSIX线程库头文件，用于多线程相关操作
#include <unistd.h>      // 包含UNIX标准库头文件，用于sleep等系统调用// 线程函数定义，参数类型为void指针以支持任意数据类型传递
void* thread_function(void* arg) {int thread_id = *(int*)arg;  // 将void指针参数转换为int指针，并解引用获取线程IDprintf("线程 %d 开始执行\n", thread_id);  // 打印线程启动信息sleep(1);                    // 使当前线程休眠1秒，模拟实际任务执行时间printf("线程 %d 执行完成\n", thread_id);  // 打印线程完成信息return NULL;                 // 线程函数返回空指针（线程正常退出）
}// 主函数入口
int main() {printf("主线程开始执行\n");  // 主线程打印启动信息pthread_t thread;          // 声明pthread_t类型变量，用于存储线程标识符int thread_id = 1;         // 定义线程ID并初始化为1（单线程场景）// 创建线程// 参数依次为：线程标识符指针、线程属性（NULL表示默认属性）、线程函数、传递给线程函数的参数pthread_create(&thread, NULL, thread_function, &thread_id);// 等待线程完成（线程同步）// 参数依次为：要等待的线程标识符、接收线程返回值的指针（此处为NULL）pthread_join(thread, NULL);printf("主线程执行完成\n");  // 所有子线程结束后打印主线程结束信息return 0;                   // 主函数返回0，表示程序正常退出
}

问题验证：

如何使用pthread_create创建线程？
什么是pthread_join的作用？

三、线程同步与互斥锁

1. 竞态条件（Race Condition）

竞态条件是指多个线程同时访问和修改共享资源时，由于操作顺序不确定而导致的不一致状态。竞态条件是多线程编程中一个非常严重的问题。

示例验证：竞态条件的演示

#include <stdio.h>       // 包含标准输入输出函数头文件，用于printf等函数
#include <stdlib.h>      // 包含标准库函数头文件，用于内存分配等操作
#include <pthread.h>     // 包含POSIX线程库头文件，用于多线程相关操作
#include <unistd.h>      // 包含UNIX标准库头文件，用于sleep系统调用int balance = 0;         // 定义全局共享变量balance并初始化为0（存在线程安全问题）// 线程函数定义，参数类型为void指针以支持任意数据类型传递
void* thread_function(void* arg) {int deposit = *(int*)arg;  // 将void指针参数转换为int指针，并解引用获取存款金额sleep(1);            // 使当前线程休眠1秒，模拟网络延迟导致的竞态条件场景balance += deposit;  // 将存款金额累加到全局变量balance（非原子操作，存在竞态风险）return NULL;         // 线程函数返回空指针（线程正常退出）
}// 主函数入口
int main() {printf("初始余额: %d\n", balance);  // 打印操作前的初始余额pthread_t threads[2];    // 声明pthread_t类型数组，用于存储两个线程标识符int deposits[2] = {100, 200};  // 定义存款金额数组，包含两个待累加的值// 循环创建两个线程模拟并发存款操作for (int i = 0; i < 2; i++) {  // i为循环计数器，范围0到1// 创建新线程，参数依次为：线程标识符指针、线程属性、线程函数、参数地址pthread_create(&threads[i], NULL, thread_function, &deposits[i]);}// 循环等待所有线程执行完毕（线程同步）for (int i = 0; i < 2; i++) {  // i为循环计数器，范围0到1pthread_join(threads[i], NULL);  // 阻塞主线程直到指定线程完成}printf("最终余额: %d\n", balance);  // 打印存在并发风险的最终余额（可能非预期值）return 0;                   // 主函数返回0，表示程序正常退出
}

问题验证：

什么是竞态条件？
如何避免竞态条件？

2. 互斥锁（Mutex）

互斥锁是一种同步机制，用于防止多个线程同时访问共享资源。pthread库提供了互斥锁的实现。

示例验证：互斥锁的使用

#include <stdio.h>       // 包含标准输入输出函数头文件，用于printf等函数
#include <stdlib.h>      // 包含标准库函数头文件，用于内存分配等操作
#include <pthread.h>     // 包含POSIX线程库头文件，用于多线程相关操作
#include <unistd.h>      // 包含UNIX标准库头文件，用于sleep系统调用int balance = 0;         // 定义全局共享余额变量，初始值为0
pthread_mutex_t balance_mutex;  // 定义互斥锁变量，用于保护共享余额的访问// 线程函数定义，参数类型为void指针以支持任意数据类型传递
void* thread_function(void* arg) {int deposit = *(int*)arg;  // 将void指针参数转换为int指针，解引用获取存款金额sleep(1);            // 使当前线程休眠1秒，模拟网络延迟导致的竞态条件场景// 临界区开始：获取互斥锁（阻塞直到获得锁）pthread_mutex_lock(&balance_mutex);balance += deposit;  // 安全的余额累加操作（受互斥锁保护）pthread_mutex_unlock(&balance_mutex);  // 释放互斥锁// 临界区结束return NULL;         // 线程函数返回空指针（线程正常退出）
}// 主函数入口
int main() {printf("初始余额: %d\n", balance);  // 打印操作前的初始余额pthread_t threads[2];    // 声明线程标识符数组，存储两个线程的IDint deposits[2] = {100, 200};  // 定义存款金额数组，包含两个待累加的值// 初始化互斥锁（第二个参数NULL表示使用默认属性）pthread_mutex_init(&balance_mutex, NULL);// 循环创建两个存款线程for (int i = 0; i < 2; i++) {  // i为循环计数器，范围0到1// 创建新线程，参数依次为：线程ID指针、线程属性、线程函数、参数地址pthread_create(&threads[i], NULL, thread_function, &deposits[i]);}// 等待所有线程执行完毕（线程同步）for (int i = 0; i < 2; i++) {  // i为循环计数器，范围0到1pthread_join(threads[i], NULL);  // 阻塞主线程直到指定线程完成}// 销毁互斥锁（释放系统资源）pthread_mutex_destroy(&balance_mutex);printf("最终余额: %d\n", balance);  // 打印正确的最终余额（保证线程安全的结果）return 0;                   // 主函数返回0，表示程序正常退出
}

问题验证：

什么是互斥锁？
如何使用互斥锁避免竞态条件？

四、条件变量与信号量

1. 条件变量（Condition Variable）

条件变量用于线程之间的同步，它允许一个线程等待某个条件满足，然后继续执行。

示例验证：条件变量的使用

#include <stdio.h>       // 包含标准输入输出函数头文件，用于printf等函数
#include <stdlib.h>      // 包含标准库函数头文件，用于内存分配等操作
#include <pthread.h>     // 包含POSIX线程库头文件，用于多线程操作
#include <unistd.h>      // 包含UNIX标准库头文件，用于sleep系统调用int water_level = 0;     // 定义全局水位变量并初始化为0
pthread_mutex_t water_mutex;  // 定义互斥锁变量，用于保护水位变量的并发访问
pthread_cond_t water_cond;    // 定义条件变量，用于线程间水位状态的通知// 传感器线程函数（持续检测水位）
void* thread_function(void* arg) {while (1) {  // 无限循环模拟持续检测sleep(1);  // 模拟每秒检测一次水位的延迟// 加锁保护临界区pthread_mutex_lock(&water_mutex);water_level++;  // 水位递增printf("水位: %d\n", water_level);  // 打印当前水位// 水位达到阈值时广播通知所有等待线程if (water_level >= 10) {pthread_cond_broadcast(&water_cond);  // 使用广播通知所有等待线程}// 解锁临界区pthread_mutex_unlock(&water_mutex);}return NULL;
}// 监控线程函数（水位阈值监控）
void* monitor_function(void* arg) {// 加锁进入条件判断临界区pthread_mutex_lock(&water_mutex);// 使用while循环避免虚假唤醒while (water_level < 10) {// 等待条件变量的通知（自动释放锁并阻塞线程）pthread_cond_wait(&water_cond, &water_mutex);  // 唤醒时自动重新获得锁}// 解锁临界区pthread_mutex_unlock(&water_mutex);printf("水位已达到10，停止水泵\n");  // 执行水位达到后的动作return NULL;
}// 主函数
int main() {printf("程序开始运行\n");  // 程序启动提示pthread_t sensor_thread, monitor_thread;  // 定义两个线程标识符// 初始化互斥锁（使用默认属性）pthread_mutex_init(&water_mutex, NULL);// 初始化条件变量（使用默认属性）pthread_cond_init(&water_cond, NULL);// 创建传感器线程（参数依次为：线程指针、属性、函数、参数）pthread_create(&sensor_thread, NULL, thread_function, NULL);// 创建监控线程pthread_create(&monitor_thread, NULL, monitor_function, NULL);// 等待传感器线程完成（此时由于无限循环，实际上不会返回）pthread_join(sensor_thread, NULL);// 等待监控线程完成pthread_join(monitor_thread, NULL);// 销毁互斥锁资源pthread_mutex_destroy(&water_mutex);// 销毁条件变量资源pthread_cond_destroy(&water_cond);printf("程序结束\n");  // 程序终止提示（实际不会执行到此处）return 0;
}

问题验证：

什么是条件变量？
如何使用条件变量实现线程间的同步？

2. 信号量（Semaphore）

信号量是一种更高级的同步机制，用于控制多个线程对共享资源的访问。

示例验证：信号量的使用

#include <stdio.h>       // 包含标准输入输出库（用于printf等函数）
#include <stdlib.h>      // 包含标准库函数（用于动态内存管理等）
#include <pthread.h>     // 包含POSIX线程库（用于多线程操作）
#include <unistd.h>      // 包含UNIX标准库（用于sleep系统调用）#define MAX_CHAIRS 3     // 定义咖啡厅的最大椅子数量
#define MAX_CUSTOMERS 5  // 定义最大客户数量pthread_mutex_t coffee_mutex;  // 定义互斥锁，保护共享资源chairs
pthread_cond_t coffee_cond;    // 定义条件变量，用于客户等待通知
int chairs = MAX_CHAIRS;       // 当前可用椅子数量（共享资源）// 客户线程函数
void* customer_function(void* arg) {int customer_id = *(int*)arg;  // 将void指针参数转换为客户IDwhile (1) {  // 无限循环模拟客户持续行为// 加锁（进入临界区）pthread_mutex_lock(&coffee_mutex);if (chairs > 0) {           // 检查是否有空闲椅子chairs--;               // 占用一个椅子printf("客户 %d 已就座，剩余椅子: %d\n", customer_id, chairs);// 解锁（退出临界区）pthread_mutex_unlock(&coffee_mutex);sleep(2);  // 模拟客户用餐时间（此时未持有锁）// 重新加锁（准备释放椅子）pthread_mutex_lock(&coffee_mutex);chairs++;               // 释放一个椅子printf("客户 %d 已离开，剩余椅子: %d\n", customer_id, chairs);// 解锁pthread_mutex_unlock(&coffee_mutex);} else {printf("客户 %d 等待，剩余椅子: %d\n", customer_id, chairs);// 等待条件变量（自动释放锁并阻塞，唤醒时自动重新获得锁）pthread_cond_wait(&coffee_cond, &coffee_mutex);}// 解锁（可能由wait自动释放或手动释放）pthread_mutex_unlock(&coffee_mutex);}return NULL;
}// 服务员线程函数
void* waiter_function(void* arg) {while (1) {sleep(5);  // 每5秒检查一次椅子状态（模拟服务周期）// 加锁（进入临界区）pthread_mutex_lock(&coffee_mutex);if (chairs < MAX_CHAIRS) {  // 检查椅子是否被占用chairs = MAX_CHAIRS;    // 重置椅子数量printf("服务员已补充椅子，剩余椅子: %d\n", chairs);// 广播通知所有等待客户（唤醒阻塞线程）pthread_cond_broadcast(&coffee_cond);}// 解锁pthread_mutex_unlock(&coffee_mutex);}return NULL;
}int main() {printf("咖啡厅开始营业\n");pthread_t customers[MAX_CUSTOMERS];  // 客户线程标识符数组pthread_t waiter_thread;            // 服务员线程标识符int customer_ids[MAX_CUSTOMERS];    // 客户ID数组// 初始化互斥锁（默认属性）pthread_mutex_init(&coffee_mutex, NULL);// 初始化条件变量（默认属性）pthread_cond_init(&coffee_cond, NULL);// 创建客户线程for (int i = 0; i < MAX_CUSTOMERS; i++) {customer_ids[i] = i + 1;  // 分配客户ID（1~5）// 创建线程（参数：线程指针、属性、函数、参数）pthread_create(&customers[i], NULL, customer_function, &customer_ids[i]);}// 创建服务员线程pthread_create(&waiter_thread, NULL, waiter_function, NULL);// 等待所有线程完成（此处因无限循环实际不会执行完）for (int i = 0; i < MAX_CUSTOMERS; i++) {pthread_join(customers[i], NULL);}pthread_join(waiter_thread, NULL);// 销毁互斥锁和条件变量（实际不会执行到此处）pthread_mutex_destroy(&coffee_mutex);pthread_cond_destroy(&coffee_cond);printf("咖啡厅结束营业\n");  // 程序终止提示（理论上不可达）return 0;
}

问题验证：

什么是信号量？
如何使用信号量实现资源的互斥访问？

五、多线程编程的注意事项

1. 避免死锁（Deadlock）

死锁是指多个线程互相等待对方释放资源，导致程序无法继续执行。避免死锁的方法包括：

使用超时机制。
避免嵌套锁。
使用优先级继承。

2. 处理线程取消

线程取消（Thread Cancellation）允许一个线程终止另一个线程的执行。使用pthread_cancel函数可以取消一个线程，但需要确保取消点的安全性。

3. 资源管理

在多线程编程中，资源管理非常重要。确保每个线程只访问自己需要的资源，并正确释放资源。

示例验证：避免死锁

#include <stdio.h>       // 包含标准输入输出库，用于printf等函数
#include <stdlib.h>      // 包含标准库函数，用于动态内存管理等操作
#include <pthread.h>     // 包含POSIX线程库，用于多线程操作
#include <unistd.h>      // 包含UNIX标准库，用于sleep系统调用pthread_mutex_t mutex1, mutex2;  // 定义两个互斥锁变量mutex1和mutex2// 线程1执行函数
void* thread_function(void* arg) {while (1) {  // 无限循环模拟持续操作// 线程1尝试获取mutex1，然后获取mutex2（错误顺序导致死锁风险）pthread_mutex_lock(&mutex1);  // 加锁mutex1（临界区开始）sleep(1);                    // 模拟长时间操作，增加死锁发生概率pthread_mutex_lock(&mutex2);  // 尝试获取mutex2（此时mutex2可能已被线程2持有）// 使用共享资源（临界区操作）printf("线程1操作资源\n");pthread_mutex_unlock(&mutex1);  // 先释放mutex1（解锁顺序与加锁顺序不一致）pthread_mutex_unlock(&mutex2);  // 释放mutex2（临界区结束）}return NULL;
}// 线程2执行函数
void* thread_function2(void* arg) {while (1) {  // 无限循环模拟持续操作// 线程2尝试获取mutex2，然后获取mutex1（形成环形等待）pthread_mutex_lock(&mutex2);  // 加锁mutex2（临界区开始）sleep(1);                    // 模拟长时间操作pthread_mutex_lock(&mutex1);  // 尝试获取mutex1（此时mutex1可能已被线程1持有）// 使用共享资源printf("线程2操作资源\n");pthread_mutex_unlock(&mutex2);  // 先释放mutex2pthread_mutex_unlock(&mutex1);  // 释放mutex1（临界区结束）}return NULL;
}int main() {printf("程序开始运行\n");pthread_t thread1, thread2;  // 定义两个线程标识符// 初始化互斥锁（使用默认属性）pthread_mutex_init(&mutex1, NULL);  // 初始化mutex1pthread_mutex_init(&mutex2, NULL);  // 初始化mutex2// 创建两个线程pthread_create(&thread1, NULL, thread_function, NULL);   // 创建线程1pthread_create(&thread2, NULL, thread_function2, NULL);  // 创建线程2// 等待两个线程完成（由于死锁实际无法正常结束）pthread_join(thread1, NULL);  // 阻塞等待线程1结束pthread_join(thread2, NULL);  // 阻塞等待线程2结束// 销毁互斥锁资源（程序因死锁无法执行到此处）pthread_mutex_destroy(&mutex1);  // 销毁mutex1pthread_mutex_destroy(&mutex2);  // 销毁mutex2printf("程序结束\n");  // 程序终止提示（实际上不可达）return 0;
}

问题验证：