【多线程】七、POSIX信号量 && 环形队列的生产者消费者模型

Ⅰ. 信号量

一、POSIX 信号量的概念

​ POSIX信号量是一种进程间通信机制，它允许进程在共享资源上进行同步和互斥访问。POSIX信号量是一种计数信号量，它可以被多个进程共享，并且可以通过系统调用进行控制。POSIX 信号量是一种强大的进程间通信机制，它可以帮助程序员实现复杂的同步和互斥操作，确保多个进程之间共享资源的正确性和安全性。

​ 信号量通常用来协调对资源的访问，其中信号计数会初始化为可用资源的数目。然后线程在资源增加时会增加计数，在删除资源时会减小计数，这些操作都以原子方式执行的！如果信号计数变为零，则表明已无可用资源。计数为零时，尝试减小信号的线程会被阻塞，直到计数大于零为止。

​ POSIX 信号量具有以下特点：

• 可以被多个进程共享，或者被同一进程中的线程共享。
• 可以被用来进行同步和互斥访问共享资源。
• 具有 原子性的计数功能，允许多个进程或者线程同时访问资源。

​ 信号量就好比电影院的票数，而我们去买票的操作就是下面会讲的 P 操作，退票的操作就是 V 操作，这些操作的过程中是原子性的，并且对于电影票数，我们是可以提前得知的，也就意味着我们不需要提前加锁去判断，因为对电影票的操作是原子性的，所以不需要关心线程安全的问题！其实这都利用了一些技术比如 CAS（Compare-And-Swap） 等，这些下面会介绍到！

二、POSIX 信号量的类型区别

POSIX信号量有两种类型：命名信号量和未命名信号量。它们有以下区别：

1. 命名方式不同：命名信号量通过一个字符串名字来标识，可以被多个进程共享，而未命名信号量只能被同一进程内的线程共享，不需要名字。
2. 创建方式不同：创建命名信号量时需要使用 sem_open() 函数，创建未命名信号量时需要使用 sem_init() 函数。
3. 销毁方式不同：销毁命名信号量时需要使用 sem_unlink() 函数，销毁未命名信号量时需要使用 sem_destroy() 函数。
4. 访问权限不同：命名信号量可以通过文件系统的权限机制来控制对其的访问权限，而对于未命名信号量，访问权限只能通过进程间的 UID 和 GID 来控制。
5. 在系统中的存储位置不同：命名信号量被存储在文件系统中的一个特殊目录中，而未命名信号量被存储在进程的地址空间中。

​

​ 其中最重要的区别就是 命名信号量通过一个字符串名字来标识，可以被多个进程共享。未命名信号量只能被同一进程内的线程共享。而接下来我们主要学习的是未命名信号量，因为其可以帮助我们实现同一进程内的线程共享，达到多线程编程目的！

三、POSIX 信号量与 SystemV 信号量的区别

​ POSIX 信号量和 SystemV 信号量作用相同，都是用于同步操作，达到无冲突的访问共享资源目的，但POSIX可以用于线程间同步。除此之外，还有一些其它的区别，下面列举出来：

1. 编程接口不同： POSIX 信号量使用函数 sem_open()、sem_close()、sem_wait()、sem_post() 等来实现，而 SystemV 信号量使用函数 semget()、semctl()、semop() 等来实现。
2. 信号量命名方式不同： POSIX 信号量采用类似于文件路径的命名方式，而 SystemV 信号量采用整数 key 值的命名方式。
3. 信号量数量不同： POSIX 信号量可以创建多个信号量，而 SystemV 信号量只有一组信号量。
4. 处理进程终止的方式不同： POSIX 信号量可以通过 sem_close() 和 sem_unlink() 函数来释放信号量资源，而 SystemV 信号量需要使用 semctl() 函数来进行释放。
5. 信号量操作的方式不同： POSIX 信号量的操作更加简洁明了，使用 sem_wait() 和 sem_post() 两个函数即可，而 SystemV 信号量需要通过 semop() 函数来实现信号量操作。

​ 总之， POSIX 信号量和 SystemV 信号量在使用方式、命名方式、数量、释放方式和操作方式等方面存在一些不同，程序员在选择使用哪一种信号量时需要根据具体的情况来决定。

Ⅱ. 线程信号量基本原理

一、为什么要引入信号量❓

​ 在引入一种新方法之前，肯定是因为我们之前使用的一些方法比如说条件变量与互斥量，存在一些短板，所以我们通过新方法可以解决这些存在的问题！

​ 还记得我们之前学条件变量的时候，为了实现互斥和同步，我们需要这样子使用互斥量和条件变量：

// 伪代码：
pthread_mutex_lock(&mutex);
while(condition_is_false)
{
    pthread_cond_wait(&cond, &mutex);
}
// 操作临界资源
// 修改条件
pthread_mutex_unlock(&mutex);

​ 上述代码中，我们每次要去操作临界资源的时候，必须先上锁，因为我们不知道条件变量是否满足，如果不提前上锁就去访问条件变量和临界资源的话，就有很大可能导致线程不安全的问题，而我们也无法在条件变量已有的资源情况下去解决这个问题。

​ 所以对于条件变量的使用每次我们就得上锁，但是我们知道，上锁是有消耗的，每次我们要去判断条件是否成立之前，如果这个条件已经不成立了，但是我们还得先上锁才能得知不成立，这不是明显消耗了不必要的资源了吗。

​ 所以我们就要学习信号量，信号量说简单一点也是一个共享资源，但是对它的操作，是原子性的，从而达到了不需要加锁就能实现判断是否需要满足信号量的要求从而对临界资源进行操作！

​ 但我们要明白的是，其实互斥锁本质也是一种信号量，只不过它只有 0 和 1 两种状态，表示是否被锁定，所以我们是可以用信号量来代替互斥锁的！

二、PV 操作

​ PV 操作也称为 wait() 和 signal() 操作，是操作系统中用于操作信号量的基本操作，它们通常与信号量一起使用来进行进程或者线程间的同步和互斥访问。

​ PV 操作分为两种：

1. P操作（proberen荷兰语：尝试降低），即 wait() 操作：它用于获取（获取或占用）一个资源或者等待某个事件的发生，其作用是 将信号量的值减一，如果 信号量的值为0，则调用进程或者线程会阻塞，等待资源或事件的发生。
2. V操作（verhogen荷兰语：增长），即 signal() 操作：它用于释放一个资源或者发出某个事件，其作用是 将信号量的值加一，如果 有其他进程或者线程在等待该信号量，则唤醒其中一个进程，让它可以继续执行。

​ 例如，当多个进程需要访问共享资源时，可以使用 PV操作 来实现互斥访问，其中 P操作 用于 占用资源，V操作 用于 释放资源。又例如，当多个进程需要等待某个事件的发生时，可以使用 PV操作 来实现等待和唤醒的操作，其中 P操作 用于等待事件的发生，V操作 用于发出事件的信号。

​ 需要注意的是，在使用 PV 操作时，需要考虑信号量的初始值，以及多个进程同时访问时可能出现的竞争条件，从而保证操作的正确性和安全性。

三、POSIX 信号量的实现原理

​ POSIX信号量的实现通常是通过原子操作来保证多个进程之间对信号量的操作是原子性的。

​ 具体地说，POSIX信号量的实现使用了一些底层硬件原语或操作系统提供的原子操作，比如 CAS（Compare-and-Swap） 等，以确保对信号量的操作是原子性的，从而避免了竞态条件和死锁等问题的出现。

​ 原子操作是一种不可中断的操作，可以在多线程或多进程并发访问共享资源的情况下，保证对共享资源的访问是原子性的。因此，使用原子操作来实现信号量操作，可以有效地避免因多进程并发访问而导致的数据竞争和互斥访问等问题。

​ 需要注意的是，原子操作在一些平台上的实现方式可能会有所不同，程序员在使用时需要根据具体的平台和操作系统来选择适当的原子操作实现。

四、CAS操作介绍

​ Compare-and-Swap（CAS）是一种常见的原子操作，也称为“比较-交换”操作，是一种比较后数据若无改变则交换数据的一种无锁操作(乐观锁)。用于实现多线程或多进程并发访问共享资源的原子性操作。

​ CAS 操作通常有三个参数：共享变量的内存地址、期望值和新值。CAS 操作首先比较共享变量的值是否等于期望值，如果相等，则将共享变量的值替换为新值；如果不相等，则不执行任何操作。在这个过程中，CAS操作具有原子性，即其他线程或进程无法同时访问共享变量，从而避免了竞态条件和数据竞争等问题。

​ CAS 操作常见于并发控制算法中，如锁、信号量、读写锁等，它可以用来保证对共享资源的访问是原子性的，从而实现并发控制的正确性和安全性。

​ 需要注意的是，CAS 操作虽然可以保证对共享变量的原子性操作，但是由于 CAS 操作涉及到对共享变量的读取和修改，因此仍然可能存在ABA问题，即在多线程或多进程并发访问共享变量的情况下，共享变量的值在某个时刻先变成了 A，然后又变成了 B，最后再变回了 A，从而导致一些问题。

​ 为了避免上述的问题，通常需要使用带有版本号等标识的 CAS 操作来解决。即在进行 CAS 操作时，不仅要比较共享变量的值是否等于期望值，还需要比较版本号是否匹配。这样可以确保即使共享变量的值在中间被修改过，但由于版本号不匹配，CAS 操作依然会失败，从而避免了上述问题的出现。

​ CAS的伪代码如下：

template bool CAS(T* addr, T expected, T value)
{
    if(*addr == expected)
    {
        *addr=value;
        return true;
    }
    return false;
}
int count=0;
void count_atomic_inc(int*addr)
{
    int oldval = 0;
    int newval = 0;
    do{
        oldval = *addr;
        newval = oldval + 1;
    }until CAS(addr, oldval, newval)
}

// 简化之后，CAS比较与交换的伪代码可以表示为：
do{
    备份旧数据；
    基于旧数据构造新数据；

}while(!CAS( 内存地址，备份的旧数据，新数据 ))

Ⅲ. POSIX未命名信号量接口

​ 我们主要是为了完成线程间的通信，所以下面主要介绍的是未命名信号量的接口，至于命名信号量接口，可以自行上网查阅！

一、初始化无名信号量

#include <semaphore.h>
int sem_init(sem_t *sem, int pshared, unsigned int value);

// 功能：初始化一个无名信号量
// 返回值：成功返回0，失败返回-1，并设置errno变量表示出错的原因

其中参数：

• sem：指向要初始化的信号量的指针。
• pshared：0 表示线程间共享，此时为未命名信号量；非 0 表示进程间共享，此时为命名信号量。
• value：信号量初始值，最大可以设置为 2147483647（SEM_VALUE_MAX）。

​ 对于 sem_t 类型结构体的定义如下：

typedef struct
{
    struct _pthread_fastlock __sem_lock; // 用于保护信号量的互斥锁，是一个pthread_fastlock类型的对象。
    int __sem_value; // 表示信号量的当前值，即信号量中的可用资源数。
    _pthread_descr __sem_waiting; // 表示正在等待信号量的线程或进程的列表，是一个_pthread_descr类型的对象。
} sem_t;

二、销毁无名信号量

#include <semaphore.h>
int sem_destroy(sem_t *sem);

// 功能：销毁一个无名信号量
// 返回值：成功返回0，失败返回-1，并设置errno变量表示出错的原因
// 参数：sem是指向要销毁的信号量的指针。

三、阻塞减少信号量（相当于P操作）

#include <semaphore.h>
int sem_wait(sem_t *sem);

// 功能：阻塞减少信号量，直到 sem 所指示的信号量计数大于零为止，之后以原子方式减小计数。
// 返回值：成功返回0，失败返回-1，并设置errno变量表示出错的原因。
// 参数：sem是指向要阻塞减少的信号量的指针。

四、非阻塞减少信号量（相当于P操作）

#include <semaphore.h>
int sem_trywait(sem_t *sem);

// 功能：在计数大于零时，尝试以原子方式减小sem所指示的信号量计数。
// 返回值：成功返回0，失败返回-1，并设置errno变量表示出错的原因。
// 参数：sem是指向要非阻塞减少的信号量的指针。

五、增加信号量（相当于V操作）

#include <semaphore.h>
int sem_post(sem_t *sem);

// 功能：以原子方式增加sem所指示的信号量，或者说给信号量解锁。
// 返回值：成功返回0，失败返回-1，并设置errno变量表示出错的原因。
// 参数：sem是指向要增加的信号量的指针。

六、读取当前信号量值

#include <semaphore.h>
int sem_getvalue(sem_t *sem, int *sval);

// 功能：读取当前信号量的值。
// 返回值：成功返回0，并将该信号量当前值存储在sval变量中；失败返回-1。
// 参数：
//     sem：指向要增加的信号量的指针。
//     sval：输出型参数，存放信号量值

测试代码：利用信号量实现互斥锁功能

#include <iostream>
#include <unistd.h>
#include <pthread.h>
#include <semaphore.h>

int global_value = 20;
sem_t mutex; // 使用信号量来实现代替互斥锁

void* thread_routine(void* args)
{
    char* namebuffer = static_cast<char*>(args);
    while(global_value)
    {
        sem_wait(&mutex); // 将mutex减一，变成0，相当于加锁，其它线程会阻塞
        if(global_value > 0)
            std::cout << namebuffer << " the global_value is " << global_value-- << std::endl;
        sem_post(&mutex); // 将mutex加一，变成1，相当于解锁，其它线程就能竞争该信号量

        usleep(10000);
    }
    return nullptr;
}

int main()
{
    sem_init(&mutex, 0, 1); // 初始化互斥信号量为1，因为互斥锁只有0和1两种状态

    // 创建多个线程
    pthread_t threads[3];
    for(int i = 0; i < 3; ++i)
    {
        char namebuffer[64];
        snprintf(namebuffer, sizeof namebuffer, "new thread %d", i+1);
        pthread_create(&threads[i], nullptr, thread_routine, namebuffer);
    }

    // 等待线程
    for(int i = 0; i < 3; ++i)
    {
        pthread_join(threads[i], nullptr);
    }

    // 销毁信号量
    sem_destroy(&mutex);
    return 0;
}

// 运行结果：
new thread 3 the global_value is 20
new thread 3 the global_value is 19
new thread 3 the global_value is 18
new thread 3 the global_value is 17
new thread 3 the global_value is 16
new thread 3 the global_value is 15
new thread 3 the global_value is 14
new thread 3 the global_value is 13
new thread 3 the global_value is 12
new thread 3 the global_value is 11
new thread 3 the global_value is 10
new thread 3 the global_value is 9
new thread 3 the global_value is 8
new thread 3 the global_value is 7
new thread 3 the global_value is 6
new thread 3 the global_value is 5
new thread 3 the global_value is 4
new thread 3 the global_value is 3
new thread 3 the global_value is 2
new thread 3 the global_value is 1

​ 这段代码使用了信号量来实现互斥，与使用互斥锁的代码实现类似。在这个例子中，sem_t 类型的 mutex 变量被用作互斥信号量，通过 sem_init 函数初始化为 1，表示初始时只有一个线程可以进入临界区。

​ 在线程的主循环中，使用 sem_wait 函数等待互斥信号量，如果信号量的值为 0，则线程会阻塞等待，直到有一个线程释放了该信号量。在临界区内，线程输出全局变量 global_value 的值，并将其减一。完成操作后，使用 sem_post 函数释放互斥信号量，表示离开临界区。在释放互斥信号量之前，其他线程无法进入临界区，保证了线程之间的互斥性。

​ 需要注意的是，在使用信号量时，每个线程需要在进入临界区之前调用 sem_wait 函数等待信号量，而在离开临界区之前调用 sem_post 函数释放信号量。这样才能保证线程之间的互斥性和同步性。

Ⅳ. 基于环形队列的生产者消费者模型

一、环形队列的应用场景

我们以前在学数据结构的时候都学过环形队列，其实环形队列的应用场景是非常多的，是一种很常用的数据结构，主要有以下应用场景：

• 数据传输：环形队列可以用于数据传输，例如网络数据包的传输，可以使用环形队列来缓存数据包，以平衡发送和接收数据的速度。
• 日志记录：环形队列可以用于记录日志，例如在多线程应用程序中，多个线程可以将日志消息写入环形队列，然后由单独的线程将日志消息写入文件，以避免由于多个线程同时写入文件而导致的文件锁竞争。
• 任务调度：环形队列可以用于任务调度，例如在多线程任务中，任务可以被添加到环形队列中，然后由单独的线程从队列中取出任务并执行。
• 缓存数据：环形队列可以用于缓存数据，例如在音视频流媒体播放器中，可以使用环形队列来缓存音视频数据，以平衡音视频的播放速度。
• 生产者消费者模型：环形队列是生产者消费者模型的一个经典实现方式，可以用于多线程并发场景下的任务调度和数据传输等。

​ 总之，环形队列是一种非常常用的数据结构，适用于多种场景，特别是需要对数据进行缓存和缓冲的场景。通过合理地使用环形队列，可以提高系统的性能和可靠性。而我们现在要学的就是其应用于生产者消费者模型的场景。

二、基于环形队列的生产者消费者模型的实现

​ 为什么我们之前学习了基于阻塞队列的生产者消费者模型，还要学习这种基于环形队列的生产者消费者模型呢❓❓❓

​ 其实最重要的不是基于环形队列的生产者消费者模型，而是我们要使用信号量来实现它！而我们上面介绍过了，信号量比起互斥锁和条件变量来实现的优势就是我们可以预先得知是否有资源可以申请，这个过程是不需要先加锁的，也就是说减少了提前加锁的消耗，提高了效率。但其实我们也是可以用互斥锁和条件变量来实现的，但是优势就体现不出来了！

​ 下面我们具体来看看是如何实现的！

​ 因为是基于环形队列，所以本质其实是一个循环数组，我们是通过这个数组的下标取模来达到环形队列的效果的！

​ 首先，当环形队列为空的时候，生产者和消费者的下标是一样的，指向起始位置；而当环形队列为满的时候，此时生产者和消费者的下标也是一样的，但是这个时候它们的指向位置是不确定的。如下图所示：

​ 这个时候对应到生产者消费者模型的时候，我们就得清楚，当 队列为空的时候，此时只能让 head 也就是生产者先走，而 tail 也就是消费者不能超过生产者，因为此时队列为空，没有资源，但对于生产者来说此时是生产的时机！

​ 当 队列为满的时候，此时只能让 tail 也就是消费者先走，而 head 也就是生产者不能超过消费者，因为此时队列是满的，无法再生产资源进去，但对于消费者来说这是消费的时机！

​ 其次，当 队列不为空也不为满 的时候，此时生产者和消费者的位置是不确定的，但是它们肯定不在同一个位置，此时它们俩是 可以并发生产消费 的！

​ 而我们上面讲的 head 和 tail 的位置都可以通过数组下标来控制！

​ 并且我们提到用信号量来解决生产者和消费者同步和互斥的问题，这里我们 要用两个信号量来解决：

• 一个信号量用来控制队列中的空闲空间数量，也就是生产者可以将新数据写入队列的位置数量，当队列满时生产者需要等待消费者取走数据以腾出队列空间。
• 一个信号量用来控制队列中已有数据的数量，也就是消费者可以从队列中读取数据的数量，当队列为空时消费者需要等待生产者写入新数据以填充队列。

​ 那就有一个问题了，为什么不使用一个信号量来直接表示两者呢，空闲位置和已有数据不就是可以通过队列的长度来计算得到的吗，为啥还要折腾使用两个信号量来表示呢❓❓❓

​ 其实使用两个信号量可以更加精细地控制生产者和消费者之间的同步，避免了生产者和消费者在同一时间同时尝试读写队列的情况。如果只使用一个信号量，可能会出现生产者和消费者同时等待的情况，导致程序无法进行下去，从而产生死锁的问题。

​ 因此，使用两个信号量可以更加精细地控制生产者和消费者之间的同步，从而避免死锁问题的出现！

​ 除此之外，还有一个问题，就是我们上面虽然解决了生产者和消费者之间的同步和互斥的问题，但是对于生产者和生产者、消费者和消费者之间其实也是存在线程安全的问题的，所以我们必须再加层互斥锁，但是其实我们这里可以直接使用信号量来代替互斥锁，也就是信号量的初始值设为 1 的话就等同于互斥锁！

​ 并且我们这层加锁要放在 PV 操作之间，如果我们将这层锁放在 PV 操作外面，那么和我们之前讲的互斥锁+条件变量实现的生产者消费者模型其实就没有起到优势，因为我们通过信号量的形式就是要实现提前获取共享资源信息而不造成提前加锁的问题，所以我们 这层对于生产者和生产者、消费者和消费者之间锁要放在 PV 操作之间而不能放在 PV 操作外层！

① 无保存者版本

​ makefile 文件：

mythread : test.cpp
	g++ -o $@ $^ -std=c++11 -lpthread

.PHONY : clean
clean:
	rm -f mythread

​ RingQueue.hpp 文件：

#pragma once
#include <iostream>
#include <vector>
#include <semaphore.h>

static const int MAXSIZE =  5; // 环形队列最大数量

template <class T>
class RingQueue
{
public:
    RingQueue(const int& cap = MAXSIZE)
        :_cap(cap), _ringqueue(cap), _productor_index(0), _consumer_index(0)
    {
        // 信号量的初始化，其中互斥锁的信号量初始值为1
        sem_init(&_psem, 0, _cap);
        sem_init(&_csem, 0, 0);
        sem_init(&_pmutex, 0, 1);
        sem_init(&_cmutex, 0, 1);
    }
    ~RingQueue()
    {
        sem_destroy(&_psem);
        sem_destroy(&_csem);
        sem_destroy(&_pmutex);
        sem_destroy(&_cmutex);
    }
    void put(const T& in) // 输入型参数
    {
        // sem_wait(&_mutex); 在外面加锁的话，效率变低了

        sem_wait(&_psem);   // P操作
        sem_wait(&_pmutex); // 加锁，相当于pthread_mutex_lock();

        _ringqueue[_productor_index++] = in;
        _productor_index %= _cap; // 保证长度在队列长度内
         
        sem_post(&_pmutex); // 解锁，相当于pthread_mutex_unlock();
        sem_post(&_csem);   // V操作
    }
    void take(T* out) // 输出型参数
    {
        sem_wait(&_csem);   // P操作
        sem_wait(&_cmutex); // 加锁，相当于pthread_mutex_lock();

        *out = _ringqueue[_consumer_index++];
        _consumer_index %= _cap; // 保证长度在队列长度内

        sem_post(&_cmutex); // 解锁，相当于pthread_mutex_unlock();
        sem_post(&_psem);   // V操作
    }
private:
    std::vector<T> _ringqueue;  // 循环数组
    int _cap;                   // 队列容量
    int _productor_index;       // 生产者下标
    int _consumer_index;        // 消费者下标
    sem_t _psem;                // 生产者信号量--控制空闲空间数量
    sem_t _csem;                // 消费者信号量--控制已有数据数量
    sem_t _pmutex;              // 互斥锁信号量--防止多生产者竞争问题
    sem_t _cmutex;              // 互斥锁信号量--防止多消费者竞争问题
};

​ Task.hpp 文件：

#pragma once 
#include <iostream>
#include <functional>
#include <cstdio>
#include <string>

class CalTask
{
    using func_t = std::function<int(int, int, char)>;
public:
    CalTask()
    {}
    CalTask(int x, int y, char op, func_t func)
        :_x(x), _y(y), _op(op), _callback(func)
    {}
    std::string operator()()
    {
        int result = _callback(_x, _y, _op);
        char buffer[1024];
        snprintf(buffer, sizeof buffer, "%d %c %d = %d", _x, _op, _y, result);
        return buffer;
    }
    std::string toTaskString()
    {
        char buffer[1024];
        snprintf(buffer, sizeof buffer, "%d %c %d = ?", _x, _op, _y);
        return buffer;
    }
private:
    int _x;
    int _y;
    char _op;
    func_t _callback;
};

std::string oper = "+-*/";

int caltask(int x, int y, char op)
{
    int result = 0;
    switch(op)
    {
    case '+':
        result = x + y;
        break;
    case '-':
        result = x - y;
        break;
    case '*':
        result = x * y;
        break;
    case '/':
    {
        if(y == 0)
        {
            std::cerr << "除零错误" << std::endl;
            result = -1;
        }
        else
        {
            result = x / y;
        }
    }
        break;
    default:
        break;
    }
    return result;
}

​ test.cpp 文件：

#include <iostream>
#include <sys/types.h>
#include <unistd.h>
#include <pthread.h>
#include <ctime>
#include "RingQueue.hpp"
#include "Task.hpp"

void* productor(void* args)
{
    RingQueue<CalTask>* cal_rqs = static_cast<RingQueue<CalTask>*>(args);
    while(true)
    {
        // 生产任务
        int x = rand() % 1000;
        int y = rand() % 400;
        char op = oper[rand() % oper.size()];
        CalTask ct(x, y, op, caltask);

        // 放置任务
        cal_rqs->put(ct);
        std::cout << pthread_self() << "productor线程，任务放置完毕，任务为：" << ct.toTaskString() << std::endl;
    }
    return nullptr;
}

void* consumer(void* args)
{
    RingQueue<CalTask>* cal_rqs = static_cast<RingQueue<CalTask>*>(args);
    while(true)
    {
        // 拿取任务
        CalTask ct;
        cal_rqs->take(&ct);

        // 执行任务
        std::string result = ct();
        std::cout << pthread_self() << "consumer线程，任务获取完毕，结果为：" << result << std::endl;
    }
    return nullptr;
}

int main()
{
    srand((unsigned int)time(nullptr) ^ getpid() ^ pthread_self()); // 种下随机种子

    RingQueue<CalTask>* rqs = new RingQueue<CalTask>; // 环形队列
    // 创建线程
    pthread_t p[5], c[3];
    for(int i = 0; i < 5; ++i)
        pthread_create(&p[i], nullptr, productor, rqs);
    for(int i = 0; i < 3; ++i)
        pthread_create(&c[i], nullptr, consumer, rqs);

    // 等待线程
    for(int i = 0; i < 5; ++i)
        pthread_join(p[i], nullptr);
    for(int i = 0; i < 3; ++i)
        pthread_join(c[i], nullptr);
    delete rqs;
    return 0;
}

② 有保存者版本

​ 另外，这个代码实现的内容和我们之前一样基于阻塞队列的生产者消费者模型的例子一样，同时实现一对生产者放置任务，消费者执行任务，该消费者继续作为第二对中的生产者放置该任务的结果，而第二对的消费者进行对任务的获取以及保存！

​ 此时我们需要两个环形队列，第一个环形队列跟我们上面是一样的，而第二个环形队列是用来放置第一个环形队列中执行任务的结果，并且保存到文件中！大概的模型和我们之前写的阻塞队列其实是差不多的！

​ makefile 文件：

mythread : test.cpp
	g++ -o $@ $^ -std=c++11 -lpthread

.PHONY : clean
clean:
	rm -f mythread log.txt

​ RingQueue.hpp 文件：

#pragma once
#include <iostream>
#include <vector>
#include <semaphore.h>

static const int MAXSIZE =  5; // 环形队列最大数量

template <class T>
class RingQueue
{
public:
    RingQueue(const int& cap = MAXSIZE)
        :_cap(cap), _ringqueue(cap), _productor_index(0), _consumer_index(0)
    {
        // 信号量的初始化，其中互斥锁的信号量初始值为1
        sem_init(&_psem, 0, _cap);
        sem_init(&_csem, 0, 0);
        sem_init(&_pmutex, 0, 1);
        sem_init(&_cmutex, 0, 1);
    }
    ~RingQueue()
    {
        sem_destroy(&_psem);
        sem_destroy(&_csem);
        sem_destroy(&_pmutex);
        sem_destroy(&_cmutex);
    }
    void put(const T& in) // 输入型参数
    {
        // sem_wait(&_mutex); 在外面加锁的话，效率变低了

        sem_wait(&_psem);   // P操作
        sem_wait(&_pmutex); // 加锁，相当于pthread_mutex_lock();

        _ringqueue[_productor_index++] = in;
        _productor_index %= _cap; // 保证长度在队列长度内
         
        sem_post(&_pmutex); // 解锁，相当于pthread_mutex_unlock();
        sem_post(&_csem);   // V操作
    }
    void take(T* out) // 输出型参数
    {
        sem_wait(&_csem);   // P操作
        sem_wait(&_cmutex); // 加锁，相当于pthread_mutex_lock();

        *out = _ringqueue[_consumer_index++];
        _consumer_index %= _cap; // 保证长度在队列长度内

        sem_post(&_cmutex); // 解锁，相当于pthread_mutex_unlock();
        sem_post(&_psem);   // V操作
    }
private:
    std::vector<T> _ringqueue;  // 循环数组
    int _cap;                   // 队列容量
    int _productor_index;       // 生产者下标
    int _consumer_index;        // 消费者下标
    sem_t _psem;                // 生产者信号量--控制空闲空间数量
    sem_t _csem;                // 消费者信号量--控制已有数据数量
    sem_t _pmutex;              // 互斥锁信号量--防止多生产者竞争问题
    sem_t _cmutex;              // 互斥锁信号量--防止多消费者竞争问题
};

​ Task.hpp文件：（增加SaveTask）

#pragma once 
#include <iostream>
#include <functional>
#include <cstdio>
#include <string>
#include <fstream>

class CalTask
{
    using func_t = std::function<int(int, int, char)>;
public:
    CalTask()
    {}
    CalTask(int x, int y, char op, func_t func)
        :_x(x), _y(y), _op(op), _callback(func)
    {}
    std::string operator()()
    {
        int result = _callback(_x, _y, _op);
        char buffer[1024];
        snprintf(buffer, sizeof buffer, "%d %c %d = %d", _x, _op, _y, result);
        return buffer;
    }
    std::string toTaskString()
    {
        char buffer[1024];
        snprintf(buffer, sizeof buffer, "%d %c %d = ?", _x, _op, _y);
        return buffer;
    }
private:
    int _x;
    int _y;
    char _op;
    func_t _callback;
};

std::string oper = "+-*/";

int caltask(int x, int y, char op)
{
    int result = 0;
    switch(op)
    {
    case '+':
        result = x + y;
        break;
    case '-':
        result = x - y;
        break;
    case '*':
        result = x * y;
        break;
    case '/':
    {
        if(y == 0)
        {
            std::cerr << "除零错误" << std::endl;
            result = -1;
        }
        else
        {
            result = x / y;
        }
    }
        break;
    default:
        break;
    }
    return result;
}

class SaveTask
{
    using func_t = std::function<void(const std::string&)>;
public:
    SaveTask()
    {}
    SaveTask(const std::string &message, func_t callback)
        : _message(message), _callback(callback)
    {}
    void operator()()
    {
        _callback(_message);
    }
private:
    std::string _message;
    func_t _callback;
};

void savetask(const std::string& message)
{
    // c++的文件读写方式
    std::fstream fs("./log.txt", std::fstream::out | std::fstream::app);
    fs << message << "\n";
    fs.close();
}

​ test.cpp 文件：（封装两个环形队列，增加保存者线程函数）

#include <iostream>
#include <sys/types.h>
#include <unistd.h>
#include <pthread.h>
#include <ctime>
#include "RingQueue.hpp"
#include "Task.hpp"

template <class C, class S> // C:存储 S:保存
class RingQueues
{
public:
    RingQueues()
        : cal_rq(new RingQueue<C>)
        , save_rq(new RingQueue<S>)
    {}
    ~RingQueues()
    {
        delete cal_rq;
        delete save_rq;
    }
public:
    RingQueue<C>* cal_rq;
    RingQueue<S>* save_rq;
};

void* productor(void* args)
{
    RingQueue<CalTask>* cal_rq = (static_cast<RingQueues<CalTask, SaveTask>*>(args))->cal_rq;
    while(true)
    {
        // 生产任务
        int x = rand() % 1000;
        int y = rand() % 400;
        char op = oper[rand() % oper.size()];
        CalTask ct(x, y, op, caltask);

        // 放置任务
        cal_rq->put(ct);
        std::cout << pthread_self() << "->productor线程，任务放置完毕，任务为：" << ct.toTaskString() << std::endl;
        sleep(1);
    }
    return nullptr;
}

void* consumer(void* args)
{
    RingQueue<CalTask>* cal_rq = (static_cast<RingQueues<CalTask, SaveTask>*>(args))->cal_rq;
    RingQueue<SaveTask>* save_rq = (static_cast<RingQueues<CalTask, SaveTask>*>(args))->save_rq;
    while(true)
    {
        // 拿取任务
        CalTask ct;
        cal_rq->take(&ct);

        // 执行任务
        std::string result = ct();
        std::cout << pthread_self() << "->consumer线程，任务获取完毕，结果为：" << result << std::endl;

        // 向第二个环形队列放置执行结果
        SaveTask st(result, savetask);
        save_rq->put(st);
        std::cout << pthread_self() << "->consumer线程，任务放置...." << std::endl;
    }
    return nullptr;
}

void* saver(void* args)
{
    RingQueue<SaveTask>* save_rq = (static_cast<RingQueues<CalTask, SaveTask>*>(args))->save_rq;
    while(true)
    {
        // 拿取任务
        SaveTask st;
        save_rq->take(&st);

        // 执行任务/保存任务
        st();
        std::cout << pthread_self() << "->saver线程，任务保存完毕" << std::endl;
    }
    return nullptr;
}

int main()
{
    srand((unsigned int)time(nullptr) ^ getpid() ^ pthread_self()); // 种下随机种子

    RingQueues<CalTask, SaveTask> rqs; // 环形队列封装对象
    // 创建线程
    pthread_t p[5], c[3], s[3];
    for(int i = 0; i < 5; ++i)
        pthread_create(&p[i], nullptr, productor, &rqs);
    for(int i = 0; i < 3; ++i)
        pthread_create(&c[i], nullptr, consumer, &rqs);
    for(int i = 0; i < 3; ++i)
        pthread_create(&s[i], nullptr, saver, &rqs);

    // 等待线程
    for(int i = 0; i < 5; ++i)
        pthread_join(p[i], nullptr);
    for(int i = 0; i < 3; ++i)
    {
        pthread_join(c[i], nullptr);
        pthread_join(s[i], nullptr);
    }
    return 0;
}

Ⅳ. 效率高在哪里呢❓❓❓

1. 无需频繁创建和销毁队列：通过使用环形队列，生产者和消费者可以复用队列的存储空间，避免了频繁创建和销毁队列带来的性能开销。
2. 数据在队列内存储：通过将数据存储在环形队列内，可以避免在生产者和消费者之间频繁复制数据的操作，减少了内存和CPU的开销。
3. 使用信号量和互斥锁控制并发：通过使用信号量和互斥锁，可以有效地控制生产者和消费者之间的并发访问，保证了数据的正确性和一致性。
4. 支持多线程并发访问：由于使用了信号量和互斥锁，因此可以支持多线程并发访问，提高了系统的吞吐量和并发性。也就是说当其中的一个生产者线程在放置任务的时候，不耽误其它的生产者线程进行生产任务，提高了效率；对消费者也是如此，这和基于阻塞队列的生产者消费者模型是一样的！