生产者--消费者模型之互斥锁和条件变量

生产者-消费者模型

三种关系：

（1）生产者与生产者：互斥关系；

（2）生产者与消费者：互斥与同步的关系；

（3）消费者与消费者：互斥关系；

两种角色：（1）生产者；（2）消费者；

一种交易场所：单链表；

注：交易场所通常指的是生产者生产的数据以及消费者消费的数据所保存的数据结构；

互斥锁：

定义互斥锁：

全局定义以及初始化;

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

局部定义以及初始化：

 int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr);

加锁：

int pthread_mutex_lock(pthread_mutex_t *mutex);

int pthread_mutex_trylock(pthread_mutex_t *mutex);

解锁;

int pthread_mutex_unlock(pthread_mutex_t *mutex);

销毁互斥锁：

int pthread_mutex_destroy(pthread_mutex_t *mutex);

注：为了解决临界资源的互斥访问，所以使用互斥锁进行临界资源的互斥访问；但是，互斥访问会导致某些进程或者线程的饥饿问题，所以要进行线程或者进程间的同步，使用条件变量可以实现线程间的同步。

条件变量

定义：条件变量是来描述某些资源是否到达的状态；

定义条件变量：

全局定义以及初始化：

pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

局部定义以及初始化：

int pthread_cond_init(pthread_cond_t *restrict cond,  const pthread_condattr_t *restrict attr);

等待条件变量就绪和互斥锁被解锁;

int pthread_cond_wait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex);

唤醒 在等待的线程：

（1）唤醒一个线程;

int pthread_cond_signal(pthread_cond_t *cond);

（2）唤醒多个进程：

int pthread_cond_broadcast(pthread_cond_t *cond);

销毁条件变量：

int pthread_cond_destroy(pthread_cond_t *cond);

注：条件变量通过与互斥锁的结合，解决了线程间的互斥与同步；

生产者---消费者模型

注：交易场所为C++STL的list;

producter_consumer.cpp:

#include<stdlib.h>
#include<list>
#include<pthread.h>
#include<iostream>
using namespace std;

pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
list<int> list1;

void* producter_running(void* arg)
{
    while(1)
    {
        pthread_mutex_lock(&lock);
        int data = rand()%1000;
        list1.push_front(data);
        cout<<"the producter is done........"<<data<<endl;
        pthread_mutex_unlock(&lock);
        pthread_cond_signal(&cond);
        sleep(1);
    }
}

void* consumer_running(void* arg)
{
    int data = 0;
    while(1)
    {
        data = -1;
        pthread_mutex_lock(&lock);
        if(list1.empty())
        {
            pthread_cond_wait(&cond,&lock);
        }
        data = list1.front();
        list1.pop_front();
        cout<<"the consumer is done........"<<data<<endl;
        pthread_mutex_unlock(&lock);
    }
}
int main()
{
    pthread_t producter;
    pthread_t consumer;
    pthread_create(&producter,NULL,producter_running,NULL);
    pthread_create(&consumer,NULL,consumer_running,NULL);
    cout<<"the producer id"<<producter<<endl;
    cout<<"the consumer id"<<consumer<<endl;
    pthread_join(producter,NULL);
    pthread_join(consumer,NULL);
    pthread_mutex_destroy(&lock);
    pthread_cond_destroy(&cond);
    return 0;
}

Makefile:

producter_consumer_cpp:producter_consumer.cpp
    g++ -o $@ $^ -lpthread

.PHONY:clean
clean:
    rm -f producter_consumer_cpp

运行结果：

下一篇：生产者-消费者模型用环形队列充当交易场所，使用信号量实现。

作者水平有限，若有问题，请留言，谢谢！！