利用互斥锁和条件变量实现生产者消费模型

以下内容全部来自于自旋锁_哔哩哔哩_bilibili

 

#include <stdio.h>
#include <pthread.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
#include <string.h>
#include <vector>

using namespace std;

int mesgid = 1;
// 消息的记数器。

// 缓存消息的结构体。
struct st_message
{
    int mesgid;
    char message[1024];
} stmesg;

vector<struct st_message> vcache;
// 用vector容器做缓存。
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
// 声名并初始化条件变量。
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
// 声名并初始化互斥锁。
// 消费者、出队线程主函数。
void *outcache(void *arg)
{
    struct st_message stmesg;
    while (true)
    {
        pthread_mutex_lock(&mutex);
        // 加锁。
        // 如果缓存为空，等待。 // 条件变量虚假唤醒。
        while (vcache.size() == 0)
        {
            pthread_cond_wait(&cond, &mutex);
        }
        // 从缓存中获取第一条记录，然后删除该记录。
        memcpy(&stmesg, &vcache[0], sizeof(struct st_message)); // 内存拷贝。
        vcache.erase(vcache.begin());
        pthread_mutex_unlock(&mutex);
        // 解锁。
        // 以下是处理业务的代码。
        printf("phid=%ld,mesgid=%d\n", pthread_self(), stmesg.mesgid);
        usleep(1); 
    }
}

// 生产者、把生产的数据存入缓存。
void incache(int sig)
{
    struct st_message stmesg;
    memset(&stmesg, 0, sizeof(struct st_message));
    pthread_mutex_lock(&mutex);
    // 加锁。
    // 生产数据，放入缓存。
    stmesg.mesgid = mesgid++; vcache.push_back(stmesg); // 内存拷贝。
    stmesg.mesgid = mesgid++; vcache.push_back(stmesg);
    stmesg.mesgid = mesgid++; vcache.push_back(stmesg);
    stmesg.mesgid = mesgid++; vcache.push_back(stmesg);
    stmesg.mesgid = mesgid++; vcache.push_back(stmesg);
    stmesg.mesgid = mesgid++; vcache.push_back(stmesg);
    pthread_mutex_unlock(&mutex); // 解锁。
    pthread_cond_broadcast(&cond);
    // 触发条件，激活全部的线程。
}

int main()
{
    signal(15, incache);
    // 接收15的信号，调用生产者函数。
    pthread_t thid1, thid2, thid3;
    pthread_create(&thid1, NULL, outcache, NULL);
    pthread_create(&thid2, NULL, outcache, NULL);
    pthread_create(&thid3, NULL, outcache, NULL);
    pthread_join(thid1, NULL);
    pthread_join(thid2, NULL);
    pthread_join(thid3, NULL);
    return 0;
}

我们主函数创建三个消费者线程，并且用信号启动生产者。生产者的代码没什么好说的，就是上锁然后普通的加入数据。

消费者代码中先建立一个死循环去持续的处理数据。

我们先编译运行看一下结果。

然后发送信号

 

 

我们会发现，线程是有序的执行的。详细解释以下消费者的函数之前我们得先了解 pthread_cond_wait（）函数，这个函数不是普通的等待信号发送过来就启动，这个函数的正确执行次序是，1.先解锁 2.等待条件 3.条件触发并且上锁 我们先来证明这个。

#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
#include <pthread.h>
#include <stdio.h>

pthread_mutex_t mutex;
pthread_cond_t cond;
// pthread_cont_t cond = PTHREAD_COND_INITIALIZER;
// pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

void *thread1(void *arg);
void *thread2(void *arg);
void func(int sig);

int main()
{	
	pthread_mutex_init(&mutex, NULL);
	pthread_cond_init(&cond, NULL);
	signal(15, func);
	pthread_t p1, p2;
	pthread_create(&p1, NULL, thread1, NULL);
	pthread_create(&p2, NULL, thread2, NULL);

	pthread_join(p1, NULL);
	pthread_join(p2, NULL);
	return 0;
}

void func(int sig)
{
	pthread_cond_signal(&cond);
	// pthread_cond_broadcast(&cond);
}
void *thread1(void *arg)
{
	while(1)
	{
		pthread_mutex_lock(&mutex);
		printf("线程1在等待\n");
		pthread_cond_wait(&cond, &mutex);
		printf("线程1被唤醒\n");
		pthread_mutex_unlock(&mutex);
	}
}

void *thread2(void *arg)
{
	while(1)
	{
		pthread_mutex_lock(&mutex);
		printf("线程2在等待\n");
		pthread_cond_wait(&cond, &mutex);
		printf("线程2被唤醒\n");
		pthread_mutex_unlock(&mutex);
	}
}

 这里就是创建两个线程，两个线程函数几乎一样，先上锁然后输出日志，如果pthread_cond_wait()函数是我说的那样的话，就一定会同时输出两个等待的日志，我们来试试。

明显我们的猜测应该是正确的，然后再发信号

我们发了两次信号

 

那继续接上面说，消费者函数在死循环中，先加锁然后循环等待，这里循环等待的原因是可能会存在虚假唤醒的情况，指的是在没有明确调用 pthread_cond_signal() 或者 pthread_cond_broadcast() 函数的情况下，线程也从 pthread_cond_wait() 函数中返回，造成错误的唤醒。之后就是普通的获取元素，然后删除元素，解锁，输出日志。