＜ Linux ＞多线程（信号量）_多线程信号量机制-CSDN博客

本文链接：https://blog.csdn.net/bit_zyx/article/details/129511372

1、POSIX信号量

信号量的原理

我们将可能会被多个执行流同时访问的资源叫做临界资源，临界资源需要进行保护否则会出现数据不一致等问题。
当我们仅用一个互斥锁对临界资源进行保护时，相当于我们将这块临界资源看作一个整体，同一时刻只允许一个执行流对这块临界资源进行访问。
但实际我们可以将这块临界资源再分割为多个区域，当多个执行流需要访问临界资源时，如果这些执行流访问的是临界资源的不同区域，那么我们可以让这些执行流同时访问临界资源的不同区域，此时不会出现数据不一致等问题。

信号量的概念

POSIX信号量和SystemV信号量作用相同，都是用于同步操作，达到无冲突的访问共享资源目的。但POSIX可以用于线程间同步。
信号量本质是一个计数器，是描述临界资源中资源数目的计数器，信号量能够更细粒度的对临界资源进行管理。申请信号量本质是预定某种资源。

每个执行流在进入临界区之前都应该先申请信号量，申请成功就有了操作特点的临界资源的权限，当操作完毕后就应该释放信号量：

信号量的PV操作：

P操作：我们将申请信号量称为P操作（原子的），申请信号量的本质就是申请获得临界资源中某块资源的使用权限，当申请成功时临界资源中资源的数目应该减一，因此P操作的本质就是让计数器减一。
V操作：我们将释放信号量称为V操作（原子的），释放信号量的本质就是归还临界资源中某块资源的使用权限，当释放成功时临界资源中资源的数目就应该加++，因此V操作的本质就是让计数器加++。

PV操作必须是原子的：

多个执行流为了访问临界资源会竞争式的申请信号量，因此信号量是会被多个执行流同时访问的，也就是说信号量本质也是临界资源。
但信号量本质就是用于保护临界资源的，我们不可能再用信号量去保护信号量，所以信号量的PV操作必须是原子操作。
注意：内存当中变量的++、--操作并不是原子操作，因此信号量不可能只是简单的对一个全局变量进行++、--操作。

申请信号量失败被挂起等待：

当执行流在申请信号量时，可能此时信号量的值为0，也就是说信号量描述的临界资源已经全部被申请了，此时该执行流就应该在该信号量的等待队列当中进行等待，直到有信号量被释放时再被唤醒。
注意：信号量的本质是计数器，但不意味着只有计数器，信号量还包括一个等待队列。

问1：信号量申请成功了，就一定能保证会拥有一部分临界资源吗？

只要信号量申请成功，就一定会获得指定的资源。就像申请mutex，只要拿到了锁，就可以获得临界资源，并且不担心被切换。这就是资源预定机制。我们可以把信号量设为1，当p--时为0，即加锁的过程，而v++时变为1，即释放锁的过程，我们把上述信号量称之为二元信号量。

问2：临界资源可以当成整体，可不可以看成一小部分一小部分呢？

一般是可以的，要结合具体的应用场景。

信号量函数

sem_init 初始化信号量：
#include <semaphore.h>
int sem_init(sem_t *sem, int pshared, unsigned int value);
参数说明：

sem：需要初始化的信号量。
pshared：传入0值表示线程间共享，传入非零值表示进程间共享。
value：信号量的初始值（计数器的初始值）。

返回值说明：

初始化信号量成功返回0，失败返回-1。

注意： POSIX信号量和System V信号量作用相同，都是用于同步操作，达到无冲突的访问共享资源目的，但POSIX信号量可以用于线程间同步。

sem_destroy 销毁信号量：
int sem_destroy(sem_t *sem);
参数说明：

sem：需要销毁的信号量。

返回值说明：

销毁信号量成功返回0，失败返回-1。

sem_wait 等待信号量（申请信号量）：
int sem_wait(sem_t *sem);
参数说明：

sem：需要等待的信号量。

返回值说明：

等待信号量成功返回0，信号量的值减一。
等待信号量失败返回-1，信号量的值保持不变。

sem_post 发布信号量（释放信号量）：
int sem_post(sem_t *sem);
参数说明：

sem：需要发布的信号量。

返回值说明：

发布信号量成功返回0，信号量的值加++。
发布信号量失败返回-1，信号量的值保持不变。

2、基于环形队列的生产消费模型

上一篇博文的生产者-消费者的例子是基于queue的,其空间可以动态分配,现在基于固定大小的环形队列重写这个程序。环形队列采用数组模拟（推荐数组模拟，因为缓存命中率高），用模运算来模拟环状特性。此环形队列的生产者消费者模型中，生产线程用来放数据，消费线程用来拿数据。

我们可以让生产者正在生产数据的时候，消费者同时从尾部拿数据，只要二者不访问同一个位置，这是可以并发执行的，但是它们有可能会访问到同一个位置。以前我们学习环形队列的时候是需要判空和判满的，

默认情况下，环形队列为空的时候，生产者和消费者是指向同一个位置的，随后就是生产者生产一个，消费者才往后消费一个，我们之前的方案是预留一个空位置不用，空的时候就是二者指向同一个位置，满的时候就是当前位置的下一个位置就是结尾即满。或者采用计数器的方案。

我们现在不需要考虑环形队列为满为空的，因为有信号量帮我们考虑。当我们不考虑留一个空位置的时候，发生两个执行流访问同一个位置只有当环形队列为满或为空的情况（互斥 & 同步）。其它的时候，我们都指向不同的位置。

当空的时候，消费者不能消费，而要让生产者生产，当满的时候，生产者不能生产，而要让消费者消费，这是互斥的体现
我们不能让二者同时访问一个位置并执行，要具有一定的顺序写，这是同步的体现
当二者指向不同的位置时，二者可以同时运行，这是并发的体现。

如果生产者和消费者两个执行流指向了同一个位置，那么它们谁先运行呢？解决此问题，需要分类讨论（为空 & 为满），答案如下：

空：消费者不能超过生产者，因为消费者不能读取到还没生产的数据 ——> 生产者先运行
满：生产者不能把消费者套一个圈继续再往后写入，因为这就会把你曾经生产还未被消费者拿到的数据给覆盖了 ——> 消费者先运行

注意：上述的原则是由信号量来保证的。信号量是用来描述临界资源数目多少的计数器。我们通过信号量保证了生产者和消费者的串行化过程。而除了这两种情况之外，生产者和消费者指向的都不是同一个位置，因此该环形队列当中不可能会出现数据不一致的问题。并且大部分情况下生产者和消费者指向并不是同一个位置，因此大部分情况下该环形队列可以让生产者和消费者并发的执行。

生产者和消费者的申请和释放资源

对于生产者和消费者来说，它们关注的资源是不同的：（我们假设环形队列的空间是N）

生产者关注的是环形队列当中是否有空间（room），只要有空间生产者就可以进行生产。其空间变化应该是 N -> 0
消费者关注的是环形队列当中是否有数据（data），只要有数据消费者就可以进行消费。其数据变化是0 -> N

现在我们用信号量来描述环形队列当中的空间资源（roomSem）和数据资源（dataSem），在我们初始信号量时给它们设置的初始值是不同的：

roomSem的初始值我们应该设置为环形队列的容量，因为刚开始时唤醒队列中全是空间
dataSem的初始值我们应该设置为0，因为刚开始时环形队列中没有数据

生产者申请空间资源，释放数据资源：

对于生产者而言，每次生产数据前要先申请空间资源rootSem

如果rootSem的值不为0，数据不满，还有空位放数据，则信号量申请成功，此时生产者可以进行生产操作，放入数据
如果rootSem的值为0，数据满了，没有空位放数据，则信号量申请失败，此时生产者需要在rootSem的等待队列下进行阻塞等待，直到环形队列当中有新的空间后再被唤醒（当消费者消费数据后）。

当生产者生产完数据后，应该释放数据资源dataSem

虽然生产者在进行生产前是对rootSem进行的P操作，但是当生产者生产完数据，应该对dataSem进行V操作而不是rootSem。因为生产完数据后，数据资源会多一个，所以对dataSem进行V操作。
生产者在生产数据前申请到的是room位置，当生产者生产完数据后，该位置当中存储的是生产者生产的数据，在该数据被消费者消费之前，该位置不再是room位置，而应该是data位置。
当生产者生产完数据后，意味着环形队列当中多了一个data位置，因此我们应该对dataSem进行V操作。

消费者申请数据资源，释放空间资源：

对于消费者而言，每次消费前要先申请数据资源dataSem

如果dataSem的值不为0，有数据，可以消费数据，则信号量申请成功，此时消费者可以进行消费操作。
如果dataSem的值为0，没有数据，无法消费数据，则信号量申请失败，此时消费者需要在dataSem的等待队列下进行阻塞等待，直到环形队列当中有新的数据后再被唤醒（当生产者生产数据后）。

当消费者消费完数据后，应该释放rootSem：

虽然消费者在进行消费前是对dataSem进行的P操作，但是当消费者消费完数据，应该对rootSem进行V操作而不是dataSem。因为消费完数据后，空间是会多一个，所以对rootSem进行V操作
消费者在消费数据前申请到的是data位置，当消费者消费完数据后，该位置当中的数据已经被消费过了，再次被消费就没有意义了，为了让生产者后续可以在该位置生产新的数据，我们应该将该位置算作room位置，而不是data位置。
当消费者消费完数据后，意味着环形队列当中多了一个room位置，因此我们应该对rootSem进行V操作。

代码实现（单生产者单消费者）

RingQueue.hpp文件：

上述的环形队列RingQueue就是生产者消费者模型当中的交易场所，我们可以用C++SEL库当中的vector进行实现。我们将RingQueue设计出模板类。

RingQueue的私有成员变量如下：

ringqueue_：此环形队列用数组实现的，所以我们定义一个vector数组ringqueue_
roomSem_ & dataSem_：分别用于生产者衡量空间计数器的信号量和消费者衡量数据计数器的信号量
pIndex_ & cIndex_：即下标，分别记录当前生产者写入的位置和消费者读取的位置

RingQueue的公有成员函数如下：

RingQueue构造函数：

给数组ringqueue_初始化容量为5（定义全局变量gCap），初始化消费者生产者下标为0
复用sem_init对roomSem和dataSem进行初始化

~RingQueue析构函数：

复用sem_destroy释放空间信号量和数据信号量

push生产函数：

复用sem_wait函数申请roomSem空间资源
接着把生产出的数据放入ringqueue_数组里，更新pIndex_++，为了防止pIndex_后续越界，要 % 数组ringqueue_的大小size()
创建数据后，复用sem_post函数对dataSem信号量进行V操作，因为生产数据后，数据信号量要++

pop消费函数：

复用sem_wait函数申请dataSem数据资源
定义临时变量保存要拿出的数据，拿出后不需要释放此数据，因为往后生产者生产数据会覆盖此位置
拿走数据后，空间就多了一个，复用sem_post函数对roomSem信号量进行V操作
拿走数据后，更新cIndex的位置，为了防止cIndex_后续越界，要 % 数组ringqueue_的大小size()
返回temp拿走的数据
#pragma once
#include <iostream>
#include <string>
#include <vector>
#include <semaphore.h>
using namespace std;

// 定义默认容量大小
const int gCap = 5;

template <class T>
class RingQueue
{
public:
    // 构造函数
    RingQueue(int cap = gCap)
        : ringqueue_(cap), pIndex_(0), cIndex_(0)
    {
        // 初始化空间计数器信号量
        sem_init(&roomSem_, 0, ringqueue_.size());
        // 初始化数据计数器信号量
        sem_init(&dataSem_, 0, 0);
    }
    // 析构函数
    ~RingQueue()
    {
        sem_destroy(&roomSem_);
        sem_destroy(&dataSem_);
    }
    // 生产
    void push(const T &in)
    {
        sem_wait(&roomSem_);          // 申请空间资源信号量
        ringqueue_[pIndex_] = in;     // 生产数据放入数组里
        sem_post(&dataSem_);          // V操作
        pIndex_++;                    // 更新写入的位置
        pIndex_ %= ringqueue_.size(); // 确保pIndex_的有效性
    }
    // 消费
    T pop()
    {
        sem_wait(&dataSem_);          // 申请数据资源信号量
        T temp = ringqueue_[cIndex_]; // 保存拿的数据
        sem_post(&roomSem_);          // V操作
        cIndex_++;                    // 更新读取的位置
        cIndex_ %= ringqueue_.size(); // 确保cIndex_的有效性
        return temp;
    }

private:
    vector<T> ringqueue_; // 环形队列
    sem_t roomSem_;       // 衡量空间计数器, productor
    sem_t dataSem_;       // 衡量数据计数器, consumer
    uint32_t pIndex_;     // 当前生产者写入的位置
    uint32_t cIndex_;     // 当前消费者读取的位置
};
RingQueueTest.cc文件：

环形队列需要让生产者不断生产数据，消费者不断消费数据。我们利用rand函数生成一个随机数，并让生产者把此数据push到环形队列里，而消费者就是不断从环形队列里pop数据。为了便于观察，我们可以将生产者生产的数据和消费者消费的数据进行打印输出。
#include "RingQueue.hpp"
#include <unistd.h>
#include <ctime>
// 生产者不断生产数据
void *productor(void *args)
{
    RingQueue<int> *rqp = static_cast<RingQueue<int> *>(args);
    while (true)
    {
        int data = rand() % 10;
        rqp->push(data);
        cout << "pthread[" << pthread_self() << "]" << " 生产了一个数据: " << data << endl;
        sleep(1);
    }
}
// 消费者不断消费数据
void *consumer(void *args)
{
    RingQueue<int> *rqp = static_cast<RingQueue<int> *>(args);
    while (true)
    {
        int data = rqp->pop();
        cout << "pthread[" << pthread_self() << "]" << " 消费了一个数据: " << data << endl;
    }
}
int main()
{
    srand((unsigned long)time(nullptr) ^ getpid());
    RingQueue<int> rq;
    pthread_t c, p;
    pthread_create(&p, nullptr, productor, &rq);
    pthread_create(&c, nullptr, consumer, &rq);

    pthread_join(c, nullptr);
    pthread_join(p, nullptr);

    return 0;
}
测试结果：

生产者消费者步调一致

我们控制生产者每隔1s生产一个数据，消费者每隔1s消费一个数据，这里可以看到生产者和消费者的步调一致：

生产者生产的快，消费者消费的慢

我们控制消费者每隔1s消费，生产者不断生产数据，可以看到的现象是生产者很快生产5个数据，导致空间满了，阻塞等待，随后消费者消费一个数据。往后消费者每消费一个数据，生产者生产者生产一个。

生产者生产的慢，消费者消费的快

我们控制生产者每隔1s生产数据，消费者不断消费数据。可以观察到在1s内什么现象都没有，因为生产者还未生产数据，1s后生产一个数据，消费者消费一个数据。往后又变成每生产一个，然后消费一个：

代码实现（多生产者多消费者）

上述代码我们实现的是单生产者单消费者，现在来实现一个多生产者多消费者。对于多生产者和多消费者，要遵循生产者与生产者之间互斥、消费者与消费者之间互斥、生产者与消费者之间互+同步的原则。逻辑变化如下：

加锁：

对于push生产函数和pop消费函数，已进入函数都要申请信号量资源，而多生产者多消费者就会导致多个线程同时申请信号资源进行P操作，P操作是原子的，随后就是多个线程在pIndex_位置放数据和cIndex_位置拿数据，此时的pIndex_和cIndex_就变成了临界资源，后续在访问临界区的时候，要维护生产者和生产者之间，消费者和消费者之间的互斥性。最多只允许一个线程对此临界区的写入操作。所以要对此临界区加锁。

push和pop加锁的位置：

申请信号量是资源的预定机制，因此所有线程都可以先申请信号量。最好把加锁放到申请信号量后面，至于哪个线程申请到锁，这是它们内部竞争决定的。这样做就好比如它们都拿到了门票（申请信号量），最后一个个进来（申请锁，访问临界区），此加锁过程对于pop函数也亦是如此。

RingQueue.hpp文件：

#pragma once
#include <iostream>
#include <string>
#include <vector>
#include <semaphore.h>
using namespace std;

// 定义默认容量大小
const int gCap = 5;

template <class T>
class RingQueue
{
public:
    // 构造函数
    RingQueue(int cap = gCap)
        : ringqueue_(cap), pIndex_(0), cIndex_(0)
    {
        // 初始化空间资源和数据资源信号量
        sem_init(&roomSem_, 0, ringqueue_.size());
        sem_init(&dataSem_, 0, 0);

        // 初始化生产者和消费者的锁
        pthread_mutex_init(&pmutex_, nullptr);
        pthread_mutex_init(&cmutex_, nullptr);
    }
    // 析构函数
    ~RingQueue()
    {
        //释放信号量
        sem_destroy(&roomSem_);
        sem_destroy(&dataSem_);
        //释放锁
        pthread_mutex_destroy(&pmutex_);
        pthread_mutex_destroy(&cmutex_);
    }
    // 生产
    void push(const T &in)
    {
        sem_wait(&roomSem_);          // 申请空间资源信号量
        pthread_mutex_lock(&pmutex_);

        ringqueue_[pIndex_] = in;     // 生产数据放入数组里
        pIndex_++;                    // 更新写入的位置
        pIndex_ %= ringqueue_.size(); // 确保pIndex_的有效性

        pthread_mutex_unlock(&pmutex_);
        sem_post(&dataSem_);          // V操作
    }
    // 消费
    T pop()
    {
        sem_wait(&dataSem_);          // 申请数据资源信号量
        pthread_mutex_lock(&cmutex_);

        T temp = ringqueue_[cIndex_]; // 保存拿的数据
        cIndex_++;                    // 更新读取的位置
        cIndex_ %= ringqueue_.size(); // 确保cIndex_的有效性
        
        pthread_mutex_unlock(&cmutex_);
        sem_post(&roomSem_);          // V操作
        return temp;
    }

private:
    vector<T> ringqueue_; // 环形队列
    sem_t roomSem_;       // 衡量空间计数器, productor
    sem_t dataSem_;       // 衡量数据计数器, consumer
    uint32_t pIndex_;     // 当前生产者写入的位置, 如果是多线程, pIndex_也是临界资源
    uint32_t cIndex_;     // 当前消费者读取的位置, 如果是多线程, cIndex_也是临界资源

    pthread_mutex_t pmutex_; // 生产者的锁
    pthread_mutex_t cmutex_; // 消费者的锁
};

RingQueueTest.cc文件：

#include "RingQueue.hpp"
#include <unistd.h>
#include <ctime>
// 生产者不断生产数据
void *productor(void *args)
{
    RingQueue<int> *rqp = static_cast<RingQueue<int> *>(args);
    while (true)
    {
        int data = rand() % 10;
        rqp->push(data);
        cout << "pthread[" << pthread_self() << "]" << " 生产了一个数据: " << data << endl;
        sleep(1);
    }
}
// 消费者不断消费数据
void *consumer(void *args)
{
    RingQueue<int> *rqp = static_cast<RingQueue<int> *>(args);
    while (true)
    {
        int data = rqp->pop();
        cout << "pthread[" << pthread_self() << "]" << " 消费了一个数据: " << data << endl;
    }
}
int main()
{
    srand((unsigned long)time(nullptr) ^ getpid());
    RingQueue<int> rq;
    pthread_t c1, c2, c3, p1, p2, p3;
    pthread_create(&p1, nullptr, productor, &rq);
    pthread_create(&p2, nullptr, productor, &rq);
    pthread_create(&p3, nullptr, productor, &rq);
    pthread_create(&c1, nullptr, consumer, &rq);
    pthread_create(&c2, nullptr, consumer, &rq);
    pthread_create(&c3, nullptr, consumer, &rq);

    pthread_join(c1, nullptr);
    pthread_join(c2, nullptr);
    pthread_join(c3, nullptr);
    pthread_join(p1, nullptr);
    pthread_join(p2, nullptr);
    pthread_join(p3, nullptr);

    return 0;
}