操作系统中的信号量[C/C++]_操作系统信号量-CSDN博客

本文链接：https://blog.csdn.net/Yhame/article/details/143190118

操作系统中的信号量：深入浅出讲解

在这里插入图片描述

信号量（Semaphore）是操作系统中用于解决并发控制的经典工具之一。它通过控制进程或线程对共享资源的访问，来避免竞态条件（Race Condition）的发生。在并发环境下，多个线程或进程可能需要访问同一资源，如何确保这些资源的有序和安全使用，信号量正是为此而生的。

概念介绍

信号量是一个整型计数器，能够记录当前可用资源的数量。在操作系统中，信号量通常用于两大场景：进程同步和互斥访问。进程同步是指控制多个进程在某些特定时刻的执行顺序，确保资源的共享不会导致问题。互斥访问则确保同一时间只有一个进程能够访问共享资源，以防止并发引发的数据不一致问题。
在这里插入图片描述

信号量可以分为两种类型：

计数信号量（Counting Semaphore）：它用于管理多个资源的并发访问，信号量的初始值为资源的数量。每次进程获取资源时，信号量减1；释放资源时，信号量加1。
二进制信号量（Binary Semaphore）：它的值只能是0或1，用来实现类似互斥锁Mutex的功能，确保只有一个进程可以访问资源。

信号量的核心操作有两个：P操作和V操作。
P操作（Proberen）用于请求资源，调用该操作会将信号量减1；如果信号量小于或等于0，调用进程将会被阻塞。
V操作（Verhogen）则用于释放资源，它将信号量加1；如果有等待的进程，它会唤醒其中一个。

信号量的应用

信号量广泛应用于并发编程中，尤其是生产者-消费者问题、读者-写者问题以及哲学家进餐问题。这些问题都是经典的多进程（或多线程）同步问题，信号量能够通过控制资源的可用性，确保并发系统的稳定性。

生产者-消费者问题是信号量应用的典型例子。该问题描述的是一组生产者不断向缓冲区中写入数据，而一组消费者则从缓冲区中读取数据。
为了防止缓冲区溢出或数据丢失，我们引入两个信号量：空闲信号量表示缓冲区中的空闲空间，已用信号量表示缓冲区中的数据量。此外，还需要一个互斥锁来确保生产者和消费者不会同时操作缓冲区。信号量的P操作和V操作帮助生产者等待空闲空间、消费者等待数据，同时通过互斥锁防止竞争条件的发生。

a.实例：生产者-消费者问题

生产者-消费者问题是信号量的一个经典应用。它描述了生产者线程生产数据，消费者线程消费数据，生产和消费共享一个固定大小的缓冲区。以下是逐层解释如何使用信号量解决这个问题。

b.伪代码

在伪代码层面，我们使用两个信号量和一个互斥锁来协调生产者和消费者：

空闲信号量：表示缓冲区中的空闲空间数量。
已用信号量：表示缓冲区中的已用空间数量（即可供消费的数据）。
互斥锁：确保缓冲区的操作是原子性的，防止多个线程同时操作缓冲区而产生竞态条件。

initialize semaphore empty = N (缓冲区大小)
initialize semaphore full = 0
initialize mutex = 1

Producer:
    while (true):
        produce_item()
        wait(empty)     # 等待缓冲区有空闲空间
        wait(mutex)     # 锁住缓冲区
        add_item_to_buffer()
        signal(mutex)   # 释放缓冲区锁
        signal(full)    # 通知消费者缓冲区有新数据

Consumer:
    while (true):
        wait(full)      # 等待缓冲区有数据
        wait(mutex)     # 锁住缓冲区
        remove_item_from_buffer()
        signal(mutex)   # 释放缓冲区锁
        signal(empty)   # 通知生产者有新的空闲空间
        consume_item()

c.代码示例（C语言/C++）

接下来，我们用C语言实现生产者-消费者问题，使用POSIX信号量库。

#include <iostream>
#include <pthread.h>
#include <semaphore.h>  // POSIX信号量库
#include <queue>
#include <unistd.h>     // sleep函数

using namespace std;

queue<int> buffer;      // 缓冲区
const unsigned int maxSize = 10;

sem_t empty;            // 表示空闲空间的信号量
sem_t full;             // 表示已用空间的信号量
pthread_mutex_t mutex;  // 互斥锁

void* producer(void* arg) {
    int item = 0;
    while (true) {
        sem_wait(&empty);            // 等待缓冲区有空闲空间
        pthread_mutex_lock(&mutex);  // 加锁

        // 生产数据并放入缓冲区
        buffer.push(item);
        cout << "Producer produced: " << item << endl;
        item++;

        pthread_mutex_unlock(&mutex); // 解锁
        sem_post(&full);              // 通知消费者缓冲区有新数据

        sleep(1); // 模拟生产时间
    }
    return nullptr;
}

void* consumer(void* arg) {
    while (true) {
        sem_wait(&full);              // 等待缓冲区有数据
        pthread_mutex_lock(&mutex);   // 加锁

        // 消费数据
        int item = buffer.front();
        buffer.pop();
        cout << "Consumer consumed: " << item << endl;

        pthread_mutex_unlock(&mutex); // 解锁
        sem_post(&empty);             // 通知生产者缓冲区有空闲空间

        sleep(2); // 模拟消费时间
    }
    return nullptr;
}

int main() {
    pthread_t prodThread, consThread;

    // 初始化信号量
    sem_init(&empty, 0, maxSize);  // 空闲空间信号量初始化为缓冲区大小
    sem_init(&full, 0, 0);         // 已用空间信号量初始化为0
    pthread_mutex_init(&mutex, nullptr);

    // 创建生产者和消费者线程
    pthread_create(&prodThread, nullptr, producer, nullptr);
    pthread_create(&consThread, nullptr, consumer, nullptr);

    // 等待线程结束
    pthread_join(prodThread, nullptr);
    pthread_join(consThread, nullptr);

    // 销毁信号量和互斥锁
    sem_destroy(&empty);
    sem_destroy(&full);
    pthread_mutex_destroy(&mutex);

    return 0;
}

d.代码解读

我们使用sem_wait来减少信号量（P操作），当信号量为零时，调用线程会阻塞，直到信号量大于零。
sem_post用于增加信号量（V操作），它可以唤醒被阻塞的线程。
使用pthread_mutex_lock和pthread_mutex_unlock来保护缓冲区的并发访问，确保生产者和消费者不能同时修改缓冲区，避免竞态条件。