Linux C生产者和消费者（线程）

生产者消费者问题

生产者消费者共享缓冲区，生产者向缓冲区中放数据，消费者从缓冲取中取数据，当缓冲区中被放满时，生产者进程就必须进入挂起状态，直到消费者从缓冲中取走数据时，生产者才能继续向缓冲区中存放数据，同样当缓冲取中没有数据时，消费者进程就必须进入挂起休眠状态，直到生产者向缓冲区中放入数据时，消费者才能被唤醒继续从缓冲区中取走数据。生产者消费者问题，也称有限缓冲问题，是一个多线程同步问题的经典案例。

实现目标

• 单生产者，单消费者
• 多生产者，多消费者

原理

生产者线程和消费者线程同时运行，当缓存区无数据（产品时）用pthread_cond_wait阻塞消费者，等待生产者产生一个数据（产品），利用rand()睡眠随机时间。主要原理为利用锁机制使生产者线程和消费者线程不能同时运行。

代码

单.c

/**********************************
 * 一个生产者和一个消费者
 * *******************************/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>

struct Listnode{
    int value;
    struct Listnode *next;
};

struct Listnode *head = NULL;

pthread_mutex_t lock1;// = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond1; // = PTHREAD_COND_INITIALIZER;

void producter(void *arg)
{
    while(1)
    {   
        struct Listnode *p = malloc(sizeof(struct Listnode));
        p->value = rand()%1000 + 1;
        printf("producter——————————————————>%d\n", p->value);              
        pthread_mutex_lock(&lock1);                    //如果已经被加锁则阻塞等待解锁后加锁
        p->next = head;
        head = p;
        
        pthread_mutex_unlock(&lock1);                   //解锁
        pthread_cond_signal(&cond1);                    //如果消费者被pthread_cond_wait阻塞该行代码发送信号解除阻塞
        sleep(rand() % 5);                              //睡眠随机时间
    }
}

void consumer(void *arg)
{
    while(1)
    {
        pthread_mutex_lock(&lock1);                      //如果已经被加锁则阻塞等待解锁后加锁
        struct Listnode *q;
        while(head == NULL)
        {
            pthread_cond_wait(&cond1, &lock1);            //阻塞消费者线程，等待生产者生产产品
        }
        q = head;
        printf("consumer--->%d\n",q->value);
        head = q->next;
        free(q);

        pthread_mutex_unlock(&lock1);
        sleep(rand() % 5);                               //睡眠随机时间
    }
}

int main()
{
    srand(time(NULL));  
    pthread_mutex_init(&lock1, NULL);    //初始化互斥锁
    pthread_cond_init(&cond1, NULL);     //初始化条件变量

    pthread_t pid, cid;
    int ret;
    ret = pthread_create(&pid, NULL, (void *)producter, NULL);
    if(ret != 0)
    {
        printf("Error: pthread_create producter!\n");
    }
    ret = pthread_create(&cid, NULL, (void *)consumer, NULL);
    if(ret != 0)
    {
        printf("Error: pthread_create consumer!\n");
    }

    pthread_join(pid, NULL);                      //等待生产者线程结束
    pthread_join(cid, NULL);                      //等待消费者线程结束

    pthread_mutex_destroy(&lock1);                //销毁锁
    pthread_cond_destroy(&cond1);                 //销毁条件变量

    return 0;
}

多.c

/**********************************
 * 多个生产者和多个消费者
 * *******************************/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>

struct Listnode{
    int value;
    struct Listnode *next;
};

struct Listnode *head = NULL;

pthread_mutex_t lock1;// = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond1; // = PTHREAD_COND_INITIALIZER;

void producter1(void *arg)
{
    while(1)
    {   
        struct Listnode *p = malloc(sizeof(struct Listnode));
        p->value = rand()%1000 + 1;
        printf("producter1——————————————————>%d\n", p->value);              
        pthread_mutex_lock(&lock1);
        p->next = head;
        head = p;
        
        pthread_mutex_unlock(&lock1);
        pthread_cond_signal(&cond1);
        sleep(rand() % 5);
    }
}

void producter2(void *arg)
{
    while(1)
    {   
        struct Listnode *p = malloc(sizeof(struct Listnode));
        p->value = rand()%1000 + 1;
        printf("producter2——————————————————>%d\n", p->value);              
        pthread_mutex_lock(&lock1);
        p->next = head;
        head = p;
        
        pthread_mutex_unlock(&lock1);
        pthread_cond_signal(&cond1);
        sleep(rand() % 5);
    }
}

void producter3(void *arg)
{
    while(1)
    {   
        struct Listnode *p = malloc(sizeof(struct Listnode));
        p->value = rand()%1000 + 1;
        printf("producter3——————————————————>%d\n", p->value);              
        pthread_mutex_lock(&lock1);
        p->next = head;
        head = p;
        
        pthread_mutex_unlock(&lock1);
        pthread_cond_signal(&cond1);
        sleep(rand() % 5);
    }
}

void consumer1(void *arg)
{
    while(1)
    {
        pthread_mutex_lock(&lock1);
        struct Listnode *q;
        while(head == NULL)
        {
            pthread_cond_wait(&cond1, &lock1);            //阻塞消费者线程，等待生产者生产产品
        }
        q = head;
        printf("consumer1--->%d\n",q->value);
        head = q->next;
        free(q);

        pthread_mutex_unlock(&lock1);
        sleep(rand() % 5);
    }
}

void consumer2(void *arg)
{
    while(1)
    {
        pthread_mutex_lock(&lock1);
        struct Listnode *q;
        while(head == NULL)
        {
            pthread_cond_wait(&cond1, &lock1);            //阻塞消费者线程，等待生产者生产产品
        }
        q = head;
        printf("consumer2--->%d\n",q->value);
        head = q->next;
        free(q);

        pthread_mutex_unlock(&lock1);
        sleep(rand() % 5);
    }
}

void consumer3(void *arg)
{
    while(1)
    {
        pthread_mutex_lock(&lock1);
        struct Listnode *q;
        while(head == NULL)
        {
            pthread_cond_wait(&cond1, &lock1);            //阻塞消费者线程，等待生产者生产产品
        }
        q = head;
        printf("consumer3--->%d\n",q->value);
        head = q->next;
        free(q);

        pthread_mutex_unlock(&lock1);
        sleep(rand() % 5);
    }
}

int main()
{
    srand(time(NULL));  
    pthread_mutex_init(&lock1, NULL);    //初始化互斥锁
    pthread_cond_init(&cond1, NULL);     //初始化条件变量

    pthread_t pid, cid;
    int ret;
    ret = pthread_create(&pid, NULL, (void *)producter1, NULL);
    if(ret != 0)
    {
        printf("Error: pthread_create producter!\n");
    }
    ret = pthread_create(&pid, NULL, (void *)producter2, NULL);
    if(ret != 0)
    {
        printf("Error: pthread_create producter!\n");
    }
    ret = pthread_create(&pid, NULL, (void *)producter3, NULL);
    if(ret != 0)
    {
        printf("Error: pthread_create producter!\n");
    }
    ret = pthread_create(&cid, NULL, (void *)consumer1, NULL);
    if(ret != 0)
    {
        printf("Error: pthread_create consumer!\n");
    }
    ret = pthread_create(&cid, NULL, (void *)consumer2, NULL);
    if(ret != 0)
    {
        printf("Error: pthread_create consumer!\n");
    }
    ret = pthread_create(&cid, NULL, (void *)consumer3, NULL);
    if(ret != 0)
    {
        printf("Error: pthread_create consumer!\n");
    }
    pthread_join(pid, NULL);
    pthread_join(cid, NULL);

    pthread_mutex_destroy(&lock1);
    pthread_cond_destroy(&cond1);

    return 0;
}