锁（Mutex）、信号量（Semaphore）与条件量（Condition Variable）

最新推荐文章于 2025-09-30 17:13:21 发布

原创最新推荐文章于 2025-09-30 17:13:21 发布 · 1.1k 阅读

19 ·

CC 4.0 BY-SA版权

文章标签：

#windows #linux

一、同步机制的核心意义

在多线程/多进程编程中，当多个执行流共享资源（如变量、内存、文件）时，可能因操作顺序不确定导致数据竞争（Data Race）。同步机制的作用是：

保证原子性：确保关键代码段（Critical Section）的独占访问。
协调执行顺序：控制线程/进程的执行顺序（如生产者-消费者模型）。

二、锁（Mutex）

1. 基本概念

互斥锁（Mutex）：最简单的同步工具，确保同一时间只有一个线程访问共享资源。
特性：锁被占用时，其他尝试获取锁的线程会被阻塞，直到锁被释放。

2. 使用步骤

初始化锁
进入临界区前加锁
退出临界区后解锁
销毁锁

3. 示例：多线程计数器

#include <pthread.h>
#include <stdio.h>

int counter = 0;
pthread_mutex_t lock; // 定义互斥锁

void* increment(void* arg) {
    for (int i = 0; i < 100000; i++) {
        pthread_mutex_lock(&lock); // 加锁
        counter++;
        pthread_mutex_unlock(&lock); // 解锁
    }
    return NULL;
}

int main() {
    pthread_t t1, t2;
    pthread_mutex_init(&lock, 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); // 正确输出 200000
    pthread_mutex_destroy(&lock); // 销毁锁
    return 0;
}

关键点：若不加锁，counter++（非原子操作）会导致结果错误。

三、信号量（Semaphore）

1. 基本概念

信号量：一种更通用的同步工具，可以控制多个线程对资源的访问。
类型：
- 二进制信号量：取值0或1，功能类似锁。
- 计数信号量：允许指定数量的线程同时访问资源。

2. 使用场景

限制资源并发访问数（如数据库连接池）。
生产者-消费者模型（缓冲区大小控制）。

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

#include <semaphore.h>
#include <pthread.h>
#define BUFFER_SIZE 5

int buffer[BUFFER_SIZE];
sem_t empty, full; // 定义信号量
int in = 0, out = 0;

void* producer(void* arg) {
    for (int i = 0; i < 10; i++) {
        sem_wait(&empty); // 等待空位（empty-1）
        buffer[in] = i;
        in = (in + 1) % BUFFER_SIZE;
        sem_post(&full); // 通知有数据（full+1）
    }
    return NULL;
}

void* consumer(void* arg) {
    for (int i = 0; i < 10; i++) {
        sem_wait(&full); // 等待数据（full-1）
        printf("Consumed: %d\n", buffer[out]);
        out = (out + 1) % BUFFER_SIZE;
        sem_post(&empty); // 释放空位（empty+1）
    }
    return NULL;
}

int main() {
    sem_init(&empty, 0, BUFFER_SIZE); // 初始空位数量=5
    sem_init(&full, 0, 0);            // 初始数据数量=0

    pthread_t p, c;
    pthread_create(&p, NULL, producer, NULL);
    pthread_create(&c, NULL, consumer, NULL);

    pthread_join(p, NULL);
    pthread_join(c, NULL);

    sem_destroy(&empty);
    sem_destroy(&full);
    return 0;
}

关键点：通过 empty 和 full 信号量协调生产者和消费者的执行顺序。

四、条件变量（Condition Variable）

1. 基本概念

条件变量：允许线程在某个条件不满足时主动阻塞，并在条件满足时被唤醒。
必须与互斥锁配合使用：确保检查和修改条件的原子性。

2. 使用场景

等待特定条件（如任务队列非空）。
避免忙等待（Busy Waiting），节省CPU资源。

3. 示例：任务队列调度

#include <pthread.h>
#include <stdbool.h>

pthread_mutex_t lock;
pthread_cond_t cond;   // 条件变量
bool task_available = false;

void* worker(void* arg) {
    pthread_mutex_lock(&lock);
    while (!task_available) {
        pthread_cond_wait(&cond, &lock); // 阻塞并释放锁，被唤醒后自动重新加锁
    }
    printf("Processing task...\n");
    task_available = false;
    pthread_mutex_unlock(&lock);
    return NULL;
}

void* scheduler(void* arg) {
    pthread_mutex_lock(&lock);
    task_available = true;
    pthread_cond_signal(&cond); // 唤醒等待的线程
    pthread_mutex_unlock(&lock);
    return NULL;
}

int main() {
    pthread_t t_worker, t_scheduler;
    pthread_mutex_init(&lock, NULL);
    pthread_cond_init(&cond, NULL);

    pthread_create(&t_worker, NULL, worker, NULL);
    sleep(1); // 确保worker先进入等待
    pthread_create(&t_scheduler, NULL, scheduler, NULL);

    pthread_join(t_worker, NULL);
    pthread_join(t_scheduler, NULL);

    pthread_mutex_destroy(&lock);
    pthread_cond_destroy(&cond);
    return 0;
}

关键点：

pthread_cond_wait 会原子性地释放锁并阻塞线程，被唤醒后重新获取锁。
必须使用 while 检查条件（避免虚假唤醒）。

五、三者的对比与选择

机制	用途	特点
锁	保护临界区，确保独占访问	简单、轻量，仅支持互斥
信号量	控制资源访问数量或协调执行顺序	灵活，支持计数和复杂同步逻辑
条件变量	等待特定条件成立	需与锁配合，避免忙等待

选择原则：

简单互斥 → 锁。
控制资源数量 → 信号量。
等待条件成立 → 条件变量。

六、深入：常见问题与陷阱

死锁：
- 场景：多个锁未按顺序获取。
- 解决：统一加锁顺序，或使用超时机制（如 pthread_mutex_trylock）。
优先级反转：
- 场景：低优先级线程持有高优先级线程需要的锁。
- 解决：优先级继承（如 pthread_mutexattr_setprotocol）。
虚假唤醒：
- 场景：pthread_cond_wait 可能无故返回。
- 解决：始终在 while 循环中检查条件。