一、多线程基础概念介绍

多线程编程是现代软件开发中提高程序性能和响应性的重要技术。在C语言中，pthread（POSIX Threads）库是实现多线程编程的标准工具。本节将通俗易懂地介绍多线程的核心概念，包括线程、锁、条件变量和信号量。

1. 线程：程序的“分身术”

线程是程序执行的最小单位，可以看作程序的一个“分身”。一个进程（程序运行的实例）可以包含多个线程，这些线程共享进程的内存空间，但每个线程有自己的栈和寄存器，用于独立执行代码。

• 特点：
• 线程是轻量级的，创建和销毁开销比进程小。
• 线程间共享内存，通信方便，但需注意数据竞争。
• 多线程可利用多核CPU并行执行，提升性能。
• 应用场景：Web服务器处理多个客户端请求、并行计算任务、实时数据处理等。

2. 锁：线程的“门卫”

多线程共享内存可能导致数据竞争，例如两个线程同时修改同一个变量。为了避免这种混乱，我们需要“锁”来保护共享资源。

• 互斥锁（Mutex）：确保同一时间只有一个线程访问共享资源。就像只有一个钥匙的房间，线程拿到钥匙才能进入。
• 读写锁（Read-Write Lock）：允许多个线程同时读取数据，但写操作独占资源。适合读多写少的场景。

3. 条件变量：线程的“信号灯”

条件变量用于线程间的同步，解决“线程等待特定条件”的问题。例如，一个线程需要等待另一个线程完成任务才能继续执行。

• 工作原理：条件变量与互斥锁配合使用，线程在条件不满足时“休眠”，条件满足时被“唤醒”。
• 典型场景：生产者-消费者模型中，消费者等待生产者生产数据。

4. 信号量：线程的“计数器”

信号量是一个计数器，用于控制多个线程对有限资源的访问。信号量有两种操作：

• P操作（等待）：减少信号量计数，若计数为0则阻塞。
• V操作（释放）：增加信号量计数，唤醒等待的线程。

信号量适合控制资源池（如线程池、数据库连接池）的访问。

二、pthread库模块分类介绍及示例

pthread库是C语言中实现多线程的标准库，提供了丰富的API。以下按功能分类介绍常用模块，并附上代码示例。

1. 线程管理

用于创建、终止和回收线程。

• 常用API：
• pthread_create：创建线程。
• pthread_join：等待线程结束并回收资源。
• pthread_exit：终止当前线程。
• pthread_self：获取当前线程ID。
• 示例：创建并运行一个简单线程。

 #include <pthread.h>
 #include <stdio.h>
 
 void* thread_func(void* arg) {
     printf("Thread %ld is running\n", (long)arg);
     return NULL;
 }
 
 int main() {
     pthread_t thread;
     long thread_id = 1;
     pthread_create(&thread, NULL, thread_func, (void*)thread_id);
     pthread_join(thread, NULL);
     printf("Main thread exiting\n");
     return 0;
 }

输出：线程运行信息和主线程退出信息。

2. 互斥锁

用于保护共享资源，防止数据竞争。

• 常用API：
• pthread_mutex_init：初始化互斥锁。
• pthread_mutex_lock：加锁。
• pthread_mutex_unlock：解锁。
• pthread_mutex_destroy：销毁互斥锁。
• 示例：使用互斥锁保护计数器。

 #include <pthread.h>
 #include <stdio.h>
 
 int counter = 0;
 pthread_mutex_t mutex;
 
 void* increment(void* arg) {
     for (int i = 0; i < 10000; i++) {
         pthread_mutex_lock(&mutex);
         counter++;
         pthread_mutex_unlock(&mutex);
     }
     return NULL;
 }
 
 int main() {
     pthread_t t1, t2;
     pthread_mutex_init(&mutex, NULL);
     pthread_create(&t1, NULL, increment, NULL);
     pthread_create(&t2, NULL, increment, NULL);
     pthread_join(t1, NULL);
     pthread_join(t2, NULL);
     printf("Final counter: %d\n", counter);
     pthread_mutex_destroy(&mutex);
     return 0;
 }

说明：两个线程同时增加计数器，互斥锁确保计数器不会出现错误。

3. 条件变量

用于线程间同步，等待特定条件。

• 常用API：
• pthread_cond_init：初始化条件变量。
• pthread_cond_wait：等待条件，释放锁并休眠。
• pthread_cond_signal：唤醒一个等待线程。
• pthread_cond_broadcast：唤醒所有等待线程。
• 示例：简单条件变量使用。

 #include <pthread.h>
 #include <stdio.h>
 #include <unistd.h>
 
 pthread_mutex_t mutex;
 pthread_cond_t cond;
 int ready = 0;
 
 void* consumer(void* arg) {
     pthread_mutex_lock(&mutex);
     while (!ready) {
         pthread_cond_wait(&cond, &mutex);
     }
     printf("Consumer: Data is ready!\n");
     pthread_mutex_unlock(&mutex);
     return NULL;
 }
 
 void* producer(void* arg) {
     sleep(1); // 模拟生产数据
     pthread_mutex_lock(&mutex);
     ready = 1;
     pthread_cond_signal(&cond);
     pthread_mutex_unlock(&mutex);
     return NULL;
 }
 
 int main() {
     pthread_t prod, cons;
     pthread_mutex_init(&mutex, NULL);
     pthread_cond_init(&cond, NULL);
     pthread_create(&cons, NULL, consumer, NULL);
     pthread_create(&prod, NULL, producer, NULL);
     pthread_join(prod, NULL);
     pthread_join(cons, NULL);
     pthread_mutex_destroy(&mutex);
     pthread_cond_destroy(&cond);
     return 0;
 }

说明：消费者等待生产者设置ready，条件变量实现同步。

4. 信号量

用于控制资源访问或线程同步。

• 常用API（需包含<semaphore.h>）：
• sem_init：初始化信号量。
• sem_wait：减少信号量计数。
• sem_post：增加信号量计数。
• sem_destroy：销毁信号量。
• 示例：信号量控制资源访问。

 #include <pthread.h>
 #include <semaphore.h>
 #include <stdio.h>
 
 sem_t sem;
 int resource = 0;
 
 void* worker(void* arg) {
     sem_wait(&sem);
     resource++;
     printf("Worker %ld accessed resource: %d\n", (long)arg, resource);
     sem_post(&sem);
     return NULL;
 }
 
 int main() {
     pthread_t t1, t2;
     sem_init(&sem, 0, 1); // 初始计数为1
     pthread_create(&t1, NULL, worker, (void*)1);
     pthread_create(&t2, NULL, worker, (void*)2);
     pthread_join(t1, NULL);
     pthread_join(t2, NULL);
     sem_destroy(&sem);
     return 0;
 }

说明：信号量确保一次只有一个线程访问资源。

三、生产者-消费者示例

生产者-消费者模型是多线程编程的经典场景，广泛用于任务调度、数据处理等。以下是一个完整的C语言实现，结合互斥锁和条件变量实现线程安全。

问题描述

• 生产者：生成数据并放入共享缓冲区。
• 消费者：从缓冲区取出数据进行处理。
• 要求：
• 缓冲区大小有限（如10个元素）。
• 生产者不能在缓冲区满时生产。
• 消费者不能在缓冲区空时消费。
• 线程安全，避免数据竞争。

完整代码

 #include <pthread.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
 
 #define BUFFER_SIZE 10
 #define PRODUCER_COUNT 2
 #define CONSUMER_COUNT 2
 
 // 共享缓冲区
 int buffer[BUFFER_SIZE];
 int count = 0; // 缓冲区中数据数量
 int in = 0;   // 生产者写入位置
 int out = 0;  // 消费者读取位置
 
 pthread_mutex_t mutex;
 pthread_cond_t not_full, not_empty;
 
 void* producer(void* arg) {
     long id = (long)arg;
     while (1) {
         pthread_mutex_lock(&mutex);
         while (count == BUFFER_SIZE) {
             printf("Producer %ld: Buffer full, waiting...\n", id);
             pthread_cond_wait(not_full, &mutex);
         }
         // 生产数据
         buffer[in] = rand() % 100;
         printf("Producer %ld produced: %d at index %d\n", id, buffer[in], in);
         in = (in + 1) % BUFFER_SIZE;
         count++;
         pthread_cond_signal(not_empty);
         pthread_mutex_unlock(&mutex);
         sleep(1); // 模拟生产耗时
     }
     return NULL;
 }
 
 void* consumer(void* arg) {
     long id = (long)arg;
     while (1) {
         pthread_mutex_lock(&mutex);
         while (count == 0) {
             printf("Consumer %ld: Buffer empty, waiting...\n", id);
             pthread_cond_wait(not_empty, &mutex);
         }
         // 消费数据
         int data = buffer[out];
         printf("Consumer %ld consumed: %d from index %d\n", id, data, out);
         out = (out + 1) % BUFFER_SIZE;
         count--;
         pthread_cond_signal(not_full);
         pthread_mutex_unlock(&mutex);
         sleep(2); // 模拟消费耗时
     }
     return NULL;
 }
 
 int main() {
     pthread_t producers[PRODUCER_COUNT], consumers[CONSUMER_COUNT];
     pthread_mutex_init(&mutex, NULL);
     pthread_cond_init(not_full, NULL);
     pthread_cond_init(not_empty, NULL);
 
     // 创建生产者线程
     for (long i = 0; i < PRODUCER_COUNT; i++) {
         pthread_create(&producers[i], NULL, producer, (void*)(i + 1));
     }
     // 创建消费者线程
     for (long i = 0; i < CONSUMER_COUNT; i++) {
         pthread_create(&consumers[i], NULL, consumer, (void*)(i + 1));
     }
 
     // 主线程等待（模拟运行一段时间）
     sleep(10);
 
     // 清理（实际程序可能通过信号终止）
     for (int i = 0; i < PRODUCER_COUNT; i++) {
         pthread_cancel(producers[i]);
     }
     for (int i = 0; i < CONSUMER_COUNT; i++) {
         pthread_cancel(consumers[i]);
     }
 
     pthread_mutex_destroy(&mutex);
     pthread_cond_destroy(not_full);
     pthread_cond_destroy(not_empty);
     return 0;
 }

代码说明

1. 缓冲区：使用循环数组实现，in和out分别记录生产和消费位置。
2. 同步机制：互斥锁mutex保护缓冲区操作；条件变量not_full和not_empty分别处理缓冲区满和空的情况。
3. 生产者：检查缓冲区是否满，若满则等待；否则生产数据并通知消费者。
4. 消费者：检查缓冲区是否空，若空则等待；否则消费数据并通知生产者。
5. 主线程：创建多个生产者和消费者线程，运行一段时间后终止。

运行效果

程序启动后，生产者和消费者线程交替运行，输出类似：

 Producer 1 produced: 42 at index 0
 Consumer 1 consumed: 42 from index 0
 Producer 2 produced: 17 at index 1
 Consumer 2 consumed: 17 from index 1
 Producer 1: Buffer full, waiting...
 Consumer 1 consumed: 83 from index 2
 Producer 1 produced: 95 at index 2
 ...

四、多线程编程注意事项

死锁：多个线程互相等待对方释放资源。避免方法：

• 固定锁的获取顺序。
• 使用try_lock尝试获取锁。

优先级反转：低优先级线程持有高优先级线程需要的资源。解决方法：

• 使用优先级继承。
• 尽量减少锁的持有时间。

资源泄漏：确保锁、条件变量等资源正确销毁。

调试技巧：

• 使用valgrind检查线程安全问题。
• 记录日志分析线程行为。

五、总结

C语言多线程编程通过pthread库提供了强大的并发能力。本文从基础概念入手，介绍了线程、锁、条件变量和信号量，结合代码示例讲解了pthread库的模块功能，并实现了一个生产者-消费者模型。希望这份指南能帮助开发者快速上手多线程编程，编写高效、稳定的并发程序。