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

embedded/2025/1/13 15:28:04/

信号量（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）来确保数据的一致性，而不需要阻塞其他线程。这种方法可以提高系统的性能，尤其是在多核处理器上，因为减少了线程之间的等待时间。

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

同步机制的选择

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

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

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


http://www.ppmy.cn/embedded/153588.html

相关文章

VTK知识学习（33）-交互问题2

VTK知识学习（33）-交互问题2

1、前言 主要是针对前面有过实现不了交互的情况进行说明&#xff0c;经过一些尝试和分析调用API&#xff0c;总算实现RenderWindowControl函数回调正常串接&#xff0c;当然这个移动处理事件的效果目前也没有确认。 2、使用 vtkImageReslice reslice vtkImageReslice.New();p…
阅读更多...
Git 命令代码管理详解

Git 命令代码管理详解

一、Git 初相识&#xff1a;版本控制的神器 在当今的软件开发领域&#xff0c;版本控制如同基石般重要&#xff0c;而 Git 无疑是其中最耀眼的明珠。它由 Linus Torvalds 在 2005 年创造&#xff0c;最初是为了更好地管理 Linux 内核源代码。随着时间的推移&#xff0c;Git 凭借…
阅读更多...
并发设计模式 - 优雅终止线程

并发设计模式 - 优雅终止线程

1、优雅终止线程的设计模式 思考&#xff1a;在一个线程 T1 中如何优雅的终止线程 T2&#xff1f; 正确思路&#xff1a;两阶段终止模式 1.1 两阶段终止&#xff08;Two-phase Termination&#xff09;模式——优雅的终止线程 两阶段终止&#xff08;Two-phase Termination…
阅读更多...
Q_OBJECT宏报错的问题

Q_OBJECT宏报错的问题

在Qt中继承QObject&#xff0c;并且加上Q_OBJECT宏&#xff0c;有时候会报错&#xff0c;比如我的错误&#xff1a; error: debug/httpmgr.o:httpmgr.cpp:(.rdata$.refptr._ZTV7HttpMgr[.refptr._ZTV7HttpMgr]0x0): undefined reference to vtable for HttpMgr 意思是没有虚…
阅读更多...
es分页查询

es分页查询

ES&#xff08;Elasticsearch&#xff09;分页查询通常使用 from 和 size 参数来控制查询结果的分页。from 用于指定从哪个结果开始&#xff0c;size 用于指定返回多少条记录。 示例查询 假设你想查询 my_index 索引&#xff0c;并且希望分页获取数据&#xff1a; json GET…
阅读更多...
Kafka-go语言一命速通

Kafka-go语言一命速通

记录 命令&#xff08;终端操作kafka) # 验证kafka是否启动 ps -ef | grep kafka # ps -ef 命令用于显示所有正在运行的进程的详细信息 lsof -i :9092# 启动kafka brew services start zookeeper brew services start kafka# 创建topic kafka-topics --create --topic test --p…
阅读更多...
2024信息安全网络安全等安全意识（附培训PPT下载）

2024信息安全网络安全等安全意识（附培训PPT下载）

信息安全和网络安全是现代社会中至关重要的领域&#xff0c;它们涉及保护数据、系统和网络免受未经授权的访问、破坏和滥用。以下是一些关键的安全意识和概念&#xff1a; 信息安全意识 数据保护&#xff1a;意识到个人和组织数据的敏感性和价值&#xff0c;采取措施保护数据…
阅读更多...
【Rust自学】12.1. 接收命令行参数

【Rust自学】12.1. 接收命令行参数

12.1.0. 写在正文之前 第12章要做一个实例的项目——一个命令行程序。这个程序是一个grep(Global Regular Expression Print)&#xff0c;是一个全局正则搜索和输出的工具。它的功能是在指定的文件中搜索出指定的文字。 这个项目分为这么几步&#xff1a; 接收命令行参数&am…
阅读更多...
最新文章

Copyright @ 2022~2023