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

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

article 2025/1/13 21:00:16

信号量（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 5

int 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.kler.cn/a/501251.html

相关文章：

  • C#调用OpenCvSharp实现图像的开运算和闭运算
  • 基于springboot+vue+微信小程序的宠物领养系统
  • springmvc的获取请求数据
  • 《软硬协同优化，解锁鸿蒙系统AI应用性能新高度》
  • jenkins的作用以及操作
  • Browser-Use Web UI：浏览器自动化与AI的完美结合
  • 什么是数据分析？
  • asp.net core webapi 并发请求时 怎么保证实时获取的用户信息是此次请求的？
  • 【网络安全 | 漏洞挖掘】通过监控调试模式实现价值$15k的RCE
  • 基于单片机的粮仓环境监测系统设计
  • 第32天：Web开发-PHP应用文件操作安全上传下载任意读取删除目录遍历文件包含
  • SpringCloud：gateway分发服务报302，Network Error
  • Rabbit Rocket kafka 怎么实现消息有序消费和延迟消费的
  • css 布局及动画应用（flex+transform+transition+animation）
  • 【Rust】切片类型
  • 【Pandas】pandas Series rtruediv
  • CentOS 和 Ubantu你该用哪个
  • 微信小程序mp3音频播放组件，仅需传入url即可
  • C++:string
  • 鸿蒙UI（ArkUI-方舟UI框架）
  • Python爬虫-爬取汽车之家全部汽车品牌的brandid（品牌ID）
  • 在 C# 中使用预处理器指令
  • VB.NET 正则表达式完全指南
  • 机器学习之避免过拟合的验证方法
  • HTML - 其他标签
  • ​​​​​​芯盾时代以数据为核心的车联网业务安全解决方案