Linux线程同步机制深度解析：信号量、互斥锁、条件变量与读写锁

Linux线程同步机制深度解析：信号量、互斥锁、条件变量与读写锁

一、线程同步基础

在多线程编程中，多个线程共享进程资源（如全局变量、文件描述符）时，若对共享资源的访问不加控制，会导致数据不一致或竞态条件。线程同步机制通过协调线程执行顺序，确保共享资源在任意时刻被正确访问。

二、信号量（Semaphore）

1. 核心概念

信号量本质是一个计数器，用于控制对共享资源的访问次数。分为无名信号量（线程间共享）和命名信号量（进程间共享），本文聚焦线程间同步的无名信号量。

2. 关键函数

#include <semaphore.h>// 初始化信号量（线程间共享时pshared=0，初始值value）
int sem_init(sem_t *sem, int pshared, unsigned int value);// 销毁信号量
int sem_destroy(sem_t *sem);// P操作：获取资源，信号量减1，若值<0则阻塞
int sem_wait(sem_t *sem);// V操作：释放资源，信号量加1，若值≤0则唤醒等待线程
int sem_post(sem_t *sem);

3. 示例：控制线程交替执行

#include <pthread.h>
#include <semaphore.h>sem_t sem;
void* thread_a(void *arg) {for (int i = 0; i < 5; ++i) {sem_wait(&sem);  // 申请资源printf("A"); fflush(stdout);sleep(1);printf("A"); fflush(stdout);sem_post(&sem);  // 释放资源}return NULL;
}void* thread_b(void *arg) {// 同上，打印"B"
}int main() {sem_init(&sem, 0, 1);  // 初始值1（互斥）pthread_create(&tid1, NULL, thread_a, NULL);pthread_create(&tid2, NULL, thread_b, NULL);pthread_join(tid1, NULL);pthread_join(tid2, NULL);sem_destroy(&sem);return 0;
}

4. 思考：信号量与互斥锁的区别？

• 信号量：计数器，可控制多个资源的访问（如允许多个线程同时读）。
• 互斥锁：等价于初始值为1的信号量，保证互斥访问（一次仅一个线程使用资源）。

三、互斥锁（Mutex）

1. 核心功能

互斥锁是最轻量的同步工具，确保共享资源在任意时刻仅被一个线程访问，适用于临界区保护（如全局变量、链表操作）。

2. 关键函数

#include <pthread.h>// 初始化互斥锁（默认属性NULL）
int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr);// 加锁（阻塞直到获取锁）
int pthread_mutex_lock(pthread_mutex_t *mutex);// 解锁
int pthread_mutex_unlock(pthread_mutex_t *mutex);// 销毁互斥锁
int pthread_mutex_destroy(pthread_mutex_t *mutex);

3. 示例：保护全局变量

pthread_mutex_t mutex;
int counter = 0;void* increment(void *arg) {for (int i = 0; i < 1000; ++i) {pthread_mutex_lock(&mutex);counter++;pthread_mutex_unlock(&mutex);}return NULL;
}int main() {pthread_mutex_init(&mutex, NULL);// 创建多个线程调用increment...pthread_mutex_destroy(&mutex);return 0;
}

4. 注意事项

• 死锁风险：避免多个线程以不同顺序加锁，或持有锁时调用阻塞函数。
• 性能：适合短临界区，长临界区建议用读写锁或条件变量。

四、条件变量（Condition Variable）

1. 核心概念

条件变量与互斥锁配合，让线程等待特定条件成立（如“数据已准备好”）。线程通过wait阻塞，条件满足时由其他线程signal/broadcast唤醒。

2. 关键函数

#include <pthread.h>// 初始化条件变量
int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr);// 等待条件（自动释放互斥锁，唤醒时重新加锁）
int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);// 唤醒一个等待线程
int pthread_cond_signal(pthread_cond_t *cond);// 唤醒所有等待线程
int pthread_cond_broadcast(pthread_cond_t *cond);

3. 示例：生产者-消费者模型

pthread_cond_t cond;
pthread_mutex_t mutex;
int buffer = 0;// 生产者
void* producer(void *arg) {for (int i = 0; i < 5; ++i) {pthread_mutex_lock(&mutex);buffer = i;pthread_cond_signal(&cond);  // 通知消费者pthread_mutex_unlock(&mutex);sleep(1);}return NULL;
}// 消费者
void* consumer(void *arg) {pthread_mutex_lock(&mutex);while (buffer == 0) {  // 避免虚假唤醒，用循环检查条件pthread_cond_wait(&cond, &mutex);}printf("Consumed: %d\n", buffer);pthread_mutex_unlock(&mutex);return NULL;
}

4. 深度思考：为什么条件变量需要配合互斥锁？

• 条件检查（如buffer == 0）和等待操作（pthread_cond_wait）必须原子化，否则线程可能在检查后、等待前被调度，导致错过信号（惊群效应）。互斥锁保证条件检查与等待的原子性。
• 若不加锁，可能出现：
  线程 A 检查到buffer非空，准备读取时被调度。
  线程 B 写入数据并唤醒等待线程，但线程 A 已跳过等待，导致数据被重复读取。

五、读写锁（Read-Write Lock）

1. 核心优势

允许多个线程同时读（共享模式），但写操作独占（排他模式），适用于读多写少场景（如配置文件读取、缓存查询）。

2. 关键函数

#include <pthread.h>// 初始化读写锁
int pthread_rwlock_init(pthread_rwlock_t *rwlock, const pthread_rwlockattr_t *attr);// 读锁（共享模式，可多个线程同时获取）
int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);// 写锁（排他模式，仅一个线程可获取）
int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);// 解锁
int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);

3. 示例：多读单写场景

pthread_rwlock_t rwlock;
int shared_data = 0;// 读线程
void* reader(void *arg) {for (int i = 0; i < 10; ++i) {pthread_rwlock_rdlock(&rwlock);printf("Read: %d\n", shared_data);pthread_rwlock_unlock(&rwlock);sleep(1);}return NULL;
}// 写线程
void* writer(void *arg) {for (int i = 0; i < 5; ++i) {pthread_rwlock_wrlock(&rwlock);shared_data++;pthread_rwlock_unlock(&rwlock);sleep(1);}return NULL;
}

4. 性能对比

场景	互斥锁	读写锁
单读单写	等效	等效
多读单写	低并发	高并发（读可并行）
多写	低并发	低并发（写独占）

六、线程安全与可重入函数

1. 线程安全定义

函数在多线程环境下被调用时，无论调度顺序如何，都能正确执行（无竞态条件）。

2. 不可重入函数风险

• 案例：strtok使用静态变量记录分割位置，多线程调用时会互相干扰。

  // 错误：主线程与子线程共享strtok的静态状态
  void* thread_func(void *arg) {char* token = strtok((char*)arg, ",");// ...
  }
  

3. 解决方案：可重入版本

• strtok_r（POSIX）：通过传入saveptr参数保存每个线程的分割状态。

  // 正确：每个线程维护独立的saveptr
  char* token = strtok_r(str, ",", &saveptr);
  

4. 线程安全函数特征

• 不使用全局/静态变量，或通过互斥锁保护。
• 不返回指向静态缓冲区的指针（如gethostbyname非线程安全，gethostbyname_r安全）。

七、同步机制对比与选择

机制	适用场景	优势	劣势
互斥锁	互斥访问（临界区）	轻量、简单	单线程独占，读多写少低效
信号量	资源计数（如连接池）	支持多资源控制	复杂场景易死锁
条件变量	等待特定条件（生产者-消费者）	细粒度同步	需配合互斥锁
读写锁	读多写少场景	读并发高	写操作阻塞所有读

通过合理选择同步机制，开发者能在保证数据一致性的同时，最大化多线程程序的性能。实际编码中，需结合场景（如临界区长度、读写比例）选择最适合的工具，避免过度同步或同步不足带来的问题。