当前位置：首页 > news >正文

第25章汇编语言--- 信号量与互斥锁

news 来源：原创 2025/6/19 0:39:49

信号量（Semaphore）和互斥锁（Mutex，全称Mutual Exclusion Object）是两种用于管理对共享资源的访问的同步机制。它们在多线程或多进程编程中非常重要，可以确保同一时间只有一个线程或进程能够访问特定的资源，从而避免了竞争条件（Race Condition）。下面我将详细叙述这两种机制，并给出简单的伪代码示例。

信号量（Semaphore）

信号量是一种更通用的同步原语，它允许限制同时访问临界区（Critical Section）的线程数量。信号量有一个内部计数器，表示可用资源的数量。当一个线程想要访问受保护的资源时，它必须先从信号量获取许可。如果信号量的计数器大于零，则线程可以继续执行并减少计数器；如果计数器为零，则线程会被阻塞直到计数器再次大于零。

二值信号量

当信号量的计数器只能取0或1时，我们称之为二值信号量，其行为与互斥锁类似，用于保证同一时刻只有一个线程能进入临界区。

计数信号量

计数信号量可以有多个单位，允许多个线程同时访问资源，只要不超过设定的最大数量。

信号量的基本操作：

P操作（wait/sem_wait）：尝试获取信号量，若成功则计数器减一，否则等待。
V操作（signal/sem_post）：释放信号量，增加计数器。

伪代码示例：

// 初始化信号量
sem_init(&sem, 0, 1); // 第三个参数是初始计数值// 进入临界区前
sem_wait(&sem);// 临界区代码...// 离开临界区后
sem_post(&sem);

互斥锁（Mutex）

互斥锁是一个更为严格的同步机制，它确保一次只有一个线程可以持有锁，即进入临界区。其他试图获取该锁的线程将会被阻塞，直到当前线程释放了锁。

互斥锁的基本操作：

lock操作（pthread_mutex_lock）：尝试获取锁，若成功则持有锁，否则等待。
unlock操作（pthread_mutex_unlock）：释放持有的锁。

伪代码示例：

// 初始化互斥锁
pthread_mutex_init(&mutex, NULL);// 进入临界区前
pthread_mutex_lock(&mutex);// 临界区代码...// 离开临界区后
pthread_mutex_unlock(&mutex);

汇编语言中的实现

汇编语言中并没有直接提供信号量或互斥锁这样的高级抽象。这些同步原语通常是用操作系统提供的系统调用来实现的，而这些系统调用最终会映射到内核模式下的某些指令序列，例如x86架构上的XCHG指令，它可以原子地交换两个值，常用于实现无锁算法和底层同步机制。

如果你希望看到具体的汇编代码来实现这些功能，这取决于具体的操作系统和硬件平台。不同的操作系统有不同的系统调用接口，而且汇编代码也会根据CPU架构的不同而有所变化。通常来说，这类底层实现是由操作系统开发者完成的，普通应用开发者一般不需要直接处理这些细节。

下面我会给出一些更具体的案例来说明如何使用信号量和互斥锁。为了简化示例，我将使用伪代码，并假设你是在一个支持POSIX线程（pthreads）的环境中工作。

案例 1：使用互斥锁保护共享资源

假设有多个线程需要访问一个共享的计数器变量。为了避免竞争条件，我们需要确保一次只有一个线程可以修改这个变量。我们可以使用互斥锁来实现这一点。

#include <pthread.h>
#include <stdio.h>// 共享资源
int counter = 0;
// 互斥锁
pthread_mutex_t mutex;void* increment_counter(void* arg) {// 尝试获取锁pthread_mutex_lock(&mutex);// 修改共享资源int local = counter;local++;counter = local;printf("Counter incremented to: %d\n", counter);// 释放锁pthread_mutex_unlock(&mutex);return NULL;
}int main() {// 初始化互斥锁pthread_mutex_init(&mutex, NULL);// 创建线程pthread_t threads[10];for (int i = 0; i < 10; ++i) {pthread_create(&threads[i], NULL, increment_counter, NULL);}// 等待所有线程完成for (int i = 0; i < 10; ++i) {pthread_join(threads[i], NULL);}// 销毁互斥锁pthread_mutex_destroy(&mutex);return 0;
}

案例 2：使用信号量控制并发访问

假设我们有一个生产者-消费者问题，其中多个生产者线程往缓冲区中添加数据，而多个消费者线程从缓冲区中移除数据。我们可以使用两个信号量来协调生产者和消费者之间的操作：一个用于跟踪缓冲区中的空位数量，另一个用于跟踪已填充的槽位数量。

#include <pthread.h>
#include <semaphore.h>
#include <stdio.h>
#include <stdlib.h>#define BUFFER_SIZE 5// 缓冲区
int buffer[BUFFER_SIZE];
int in = 0, out = 0;// 信号量
sem_t empty;
sem_t full;
pthread_mutex_t mutex;void* producer(void* arg) {int item;while (1) {item = rand() % 100; // 生产一项// 等待有空位sem_wait(&empty);// 进入临界区前pthread_mutex_lock(&mutex);// 添加到缓冲区buffer[in] = item;in = (in + 1) % BUFFER_SIZE;printf("Produced: %d\n", item);// 离开临界区后pthread_mutex_unlock(&mutex);// 增加full信号量sem_post(&full);// 模拟延迟sleep(rand() % 3);}
}void* consumer(void* arg) {int item;while (1) {// 等待有商品sem_wait(&full);// 进入临界区前pthread_mutex_lock(&mutex);// 从缓冲区移除item = buffer[out];out = (out + 1) % BUFFER_SIZE;printf("Consumed: %d\n", item);// 离开临界区后pthread_mutex_unlock(&mutex);// 增加empty信号量sem_post(&empty);// 模拟延迟sleep(rand() % 3);}
}int main() {// 初始化信号量和互斥锁sem_init(&empty, 0, BUFFER_SIZE); // 初始时所有位置为空sem_init(&full, 0, 0);            // 初始时没有满的位置pthread_mutex_init(&mutex, NULL);// 创建生产者和消费者线程pthread_t producers[3], consumers[2];for (int i = 0; i < 3; ++i) {pthread_create(&producers[i], NULL, producer, NULL);}for (int i = 0; i < 2; ++i) {pthread_create(&consumers[i], NULL, consumer, NULL);}// 主线程等待子线程结束（这里实际应该有个合理的退出机制）for (int i = 0; i < 3; ++i) {pthread_join(producers[i], NULL);}for (int i = 0; i < 2; ++i) {pthread_join(consumers[i], NULL);}// 销毁信号量和互斥锁sem_destroy(&empty);sem_destroy(&full);pthread_mutex_destroy(&mutex);return 0;
}

请注意，上述代码片段是简化的例子，实际应用中你需要考虑更多细节，例如错误处理、线程的优雅退出等。此外，sleep()函数用于模拟延迟，在实际应用中应当根据实际情况选择合适的同步方式。

接下来我将继续追加一些更深入的案例和概念，包括条件变量（Condition Variable）的使用、无锁编程（Lock-free Programming）的概念以及如何在实际编程中选择合适的同步机制。

案例 3：使用条件变量实现线程间的通信

条件变量是一种用于线程间通信的同步工具。它们通常与互斥锁一起使用，以等待某个特定条件的发生。当一个线程需要等待另一个线程完成某些操作时，它可以等待条件变量，而当该条件满足时，另一个线程会通知等待的线程继续执行。

生产者-消费者问题的改进版

我们可以通过条件变量来优化之前的生产者-消费者例子。这样可以减少不必要的上下文切换，并且使代码逻辑更加清晰。

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>#define BUFFER_SIZE 5int buffer[BUFFER_SIZE];
int count = 0, in = 0, out = 0;// 条件变量和互斥锁
pthread_mutex_t mutex;
pthread_cond_t not_full, not_empty;void* producer(void* arg) {while (1) {int item = rand() % 100; // 生产一项pthread_mutex_lock(&mutex);// 等待有空位while (count == BUFFER_SIZE)pthread_cond_wait(&not_full, &mutex);// 添加到缓冲区buffer[in] = item;in = (in + 1) % BUFFER_SIZE;++count;printf("Produced: %d\n", item);// 通知消费者pthread_cond_signal(&not_empty);pthread_mutex_unlock(&mutex);sleep(rand() % 3); // 模拟延迟}
}void* consumer(void* arg) {while (1) {pthread_mutex_lock(&mutex);// 等待有商品while (count == 0)pthread_cond_wait(&not_empty, &mutex);// 从缓冲区移除int item = buffer[out];out = (out + 1) % BUFFER_SIZE;--count;printf("Consumed: %d\n", item);// 通知生产者pthread_cond_signal(&not_full);pthread_mutex_unlock(&mutex);sleep(rand() % 3); // 模拟延迟}
}int main() {// 初始化互斥锁和条件变量pthread_mutex_init(&mutex, NULL);pthread_cond_init(&not_full, NULL);pthread_cond_init(&not_empty, NULL);// 创建线程pthread_t producers[3], consumers[2];for (int i = 0; i < 3; ++i) {pthread_create(&producers[i], NULL, producer, NULL);}for (int i = 0; i < 2; ++i) {pthread_create(&consumers[i], NULL, consumer, NULL);}// 主线程等待子线程结束（这里应该有一个合理的退出机制）for (int i = 0; i < 3; ++i) {pthread_join(producers[i], NULL);}for (int i = 0; i < 2; ++i) {pthread_join(consumers[i], NULL);}// 销毁互斥锁和条件变量pthread_mutex_destroy(&mutex);pthread_cond_destroy(&not_full);pthread_cond_destroy(&not_empty);return 0;
}

概念 4：无锁编程（Lock-free Programming）

无锁编程是一种避免使用锁来进行线程同步的方法。它通过原子操作（如CAS, Compare And Swap）来确保数据的一致性，而不需要阻塞其他线程。这种方法可以提高系统的性能，尤其是在多核处理器上，因为减少了线程之间的等待时间。

无锁数据结构的例子包括无锁栈、队列等。由于无锁编程复杂度较高，容易出错，所以通常只会在对性能要求极高的情况下使用，并且需要开发者对底层硬件和内存模型有深入了解。

同步机制的选择

选择合适的同步机制取决于你的具体需求：

互斥锁适合于保护共享资源，防止多个线程同时访问。
信号量适用于控制对有限数量资源的访问，或者限制并发线程的数量。
条件变量常用于线程间的协调，允许线程等待直到满足某个条件。
无锁编程适用于需要极高性能且可以接受增加开发复杂度的情况。

在实际应用中，你可能需要组合使用这些机制来达到最佳效果。例如，你可以使用条件变量配合互斥锁来实现复杂的线程同步逻辑，或者用信号量来管理资源池。正确选择和使用同步原语是编写高效、可靠的多线程程序的关键。