linux 生产者消费者模型 信号量(灯) 条件变量

生产者消费者模型：

模型对象：1.生产者(1或多个)   2.消费者(1或多个)   3.容器(商品)     

/*
    生产者和消费者模型(粗略版本)
    生产者未生产 消费者开始消费 发生错误
*/
#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
#include <stdlib.h>
//链表
struct Node
{
    int num;//数据
    struct Node * next;//保存下一个结点
};
//头结点
struct Node * head = NULL;
//生产者
void * producer(void * arg)
{
    //不断创建新的结点,添加到链表中
    while(1)
    {
        struct Node * newNode = (struct Node *)malloc(sizeof(struct Node));//malloc一个结点转化为结构体指针类型
        newNode->next = head;//新结点指向头结点
        head = newNode;//头节点更新   头插法
        newNode->num = rand() % 1000;
        printf("add node,num: %d, itd:%ld\n",newNode->num,pthread_self());
        usleep(100);
    }
    return NULL;
}
//消费者
void * customer(void * arg)
{
    while(1)
    {
        //保存头节点的指针
        struct Node * tmp = head;
        head = head->next;
        printf("delete node, num : %d, itd %ld\n",tmp->num,pthread_self());
        free(tmp);//释放结点空间
        usleep(100);
    }
    return NULL;
}
int main()
{
    //创建5个生产者线程 和 5个消费者线程 容器:链表
    pthread_t ptids[5],ctids[5];
    for(int i = 0; i < 5; i++)
    {
        pthread_create(&ptids[i], NULL, producer, NULL);
        pthread_create(&ctids[i], NULL, customer, NULL);
    }
    //线程分离
    for(int i = 0; i < 5; i++)
    {
        pthread_detach(ptids[i]);
        pthread_detach(ctids[i]);
    }
    pthread_exit(NULL);//线程退出   不执行return 0; 子线程不受影响继续执行
    return 0;
}

使用互斥量解决 段错误 问题，但效率低：

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
#include <stdlib.h>
//创建一个互斥量
pthread_mutex_t mutex;
//链表
struct Node
{
    int num;//数据
    struct Node * next;//保存下一个结点
};
//头结点
struct Node * head = NULL;
//生产者
void * producer(void * arg)
{
    //不断创建新的结点,添加到链表中
    while(1)
    {
        pthread_mutex_lock(&mutex);
        struct Node * newNode = (struct Node *)malloc(sizeof(struct Node));//malloc一个结点转化为结构体指针类型
        newNode->next = head;//新结点指向头结点
        head = newNode;//头节点更新   头插法
        newNode->num = rand() % 1000;
        printf("add node,num: %d, itd:%ld\n",newNode->num,pthread_self());
        pthread_mutex_unlock(&mutex);
        usleep(100);
    }
    return NULL;
}
//消费者
void * customer(void * arg)
{
    while(1)
    {
        pthread_mutex_lock(&mutex);
        //保存头节点的指针
        struct Node * tmp = head;
        if(head != NULL)
        {
            //有数据
            head = head->next;
            printf("delete node, num : %d, itd %ld\n",tmp->num,pthread_self());
            free(tmp);//释放
            pthread_mutex_unlock(&mutex);
            usleep(100);
        }
        else
        {
            //没有数据 也要解锁 否则会退出循环重复加锁 导致死锁
            pthread_mutex_unlock(&mutex);
        }
    }
    return NULL;
}
int main()
{
    //初始化互斥量
    pthread_mutex_init(&mutex,NULL);
    //创建5个生产者线程 和 5个消费者线程 容器:链表
    pthread_t ptids[5],ctids[5];
    for(int i = 0; i < 5; i++)
    {
        pthread_create(&ptids[i], NULL, producer, NULL);
        pthread_create(&ctids[i], NULL, customer, NULL);
    }
    //线程分离
    for(int i = 0; i < 5; i++)
    {
        pthread_detach(ptids[i]);
        pthread_detach(ctids[i]);
    }
    while(1)
    {
        sleep(10);//如果没有while循环 会结束互斥量 
    }
    pthread_mutex_destroy(&mutex);
    pthread_exit(NULL);//线程退出   不执行return 0; 子线程不受影响继续执行
    return 0;
}

条件变量(引起阻塞，解除阻塞)： 配合互斥量使用   （例如没有商品，消费者可以通知生产者生产商品） 

/*
    条件变量的类型 pthread_cond_t
    int pthread_cond_init(pthread_cond_t * restrict cond, const pthread_condattr_t * restrict attr);
    int pthread_cond_destroy(pthread_cond_t * cond);
    int pthread_cond_wait(pthread_cond_t * restrict cond, pthread_mutex_t * restrict mutex);
        - 等待, 调用了该函数, 线程会阻塞
    int pthread_cond_timedwait(pthread_cond_t * restrict cond, pthread_mutex_t * restrict mutex, const struct timespec * restrict abstime);
        - 等待多长时间, 调用了这个函数,线程会阻塞,直到指定时间结束
    int pthread_cond_signal(pthread_cond_t * cond);
        - 唤醒一个或者多个等待的线程
    int pthread_cond_broadcast(pthread_cond_t * cond);
        - 唤醒所有的等待的线程
*/
#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
#include <stdlib.h>
//创建一个互斥量
pthread_mutex_t mutex;
//创建条件变量
pthread_cond_t cond;
//链表
struct Node
{
    int num;//数据
    struct Node * next;//保存下一个结点
};
//头结点
struct Node * head = NULL;
//生产者
void * producer(void * arg)
{
    //不断创建新的结点,添加到链表中
    while(1)
    {
        pthread_mutex_lock(&mutex);
        struct Node * newNode = (struct Node *)malloc(sizeof(struct Node));//malloc一个结点转化为结构体指针类型
        newNode->next = head;//新结点指向头结点
        head = newNode;//头节点更新   头插法
        newNode->num = rand() % 1000;
        printf("add node,num: %d, itd:%ld\n",newNode->num,pthread_self());
        //只要生产了一个,就通知消费者
        pthread_cond_signal(&cond);
        pthread_mutex_unlock(&mutex);
        usleep(100);
    }
    return NULL;
}
//消费者
void * customer(void * arg)
{
    while(1)
    {
        pthread_mutex_lock(&mutex);
        //保存头节点的指针
        struct Node * tmp = head;
        //判断是否有数据
        if(head != NULL)
        {
            //有数据
            head = head->next;
            printf("delete node, num : %d, itd %ld\n",tmp->num,pthread_self());
            free(tmp);//释放
            pthread_mutex_unlock(&mutex);
            usleep(100);
        }
        else
        {
            //没有数据, 需要等待
            //当这个函数调用阻塞的时候,会对互斥锁进行解锁, 当不阻塞的时候,继续向下指向, 会重新加锁
            pthread_cond_wait(&cond, &mutex);//没有商品 传递cond 等待+解锁 有商品生产了 cond变化 重新运行 加锁 下条语句解锁
            pthread_mutex_unlock(&mutex);
        }
    }
    return NULL;
}
int main()
{
    //初始化互斥量
    pthread_mutex_init(&mutex,NULL);
    //初始化条件变量
    pthread_cond_init(&cond,NULL);
    //创建5个生产者线程 和 5个消费者线程 容器:链表
    pthread_t ptids[5],ctids[5];
    for(int i = 0; i < 5; i++)
    {
        pthread_create(&ptids[i], NULL, producer, NULL);
        pthread_create(&ctids[i], NULL, customer, NULL);
    }
    //线程分离
    for(int i = 0; i < 5; i++)
    {
        pthread_detach(ptids[i]);
        pthread_detach(ctids[i]);
    }
    while(1)
    {
        sleep(10);//如果没有while循环 会结束互斥量 
    }
    pthread_mutex_destroy(&mutex);
    pthread_cond_destroy(&cond);
    pthread_exit(NULL);//线程退出   不执行return 0; 子线程不受影响继续执行
    return 0;
}

信号量(灯)：用于阻塞线程（灯亮表明资源可用，灯灭表明资源不可用）（不能保证线程数据安全，配合互斥锁使用） 

/*
    信号量: semaphore
    信号量的类型 sem_t
    int sem_init(sem_t * sem, int pshared, unsigned int value);
        - 初始化信号量
        - 参数
            - sem: 信号量变量的地址
            - pshared: 0:用在线程间,  非0：用在进程间
            - value: 信号量中的值
    int sem_destroy(sem_t * sem);
        - 释放资源
    int sem_wait(sem_t * sem);
        - 对信号加锁 ,调用一次对信号量的值 -1, 如果值为0, 就阻塞
    int sem_trywait(sem_t * sem);
    int sem_timedwait(sem_t * sem, const struct timespec * abs_timeout);
    int sem_post(sem_t * sem);
        - 解锁一个信号量,调用一次对信号量的值 +1
    int sem_getvalue(sem_t * sem, int * sval);

    sem_t psem;
    sem_t csem;
    init(psem, 0, 8); //8是初始量 生产者的限制值 生产调用减少同时产生商品 消费调用增加同时消费商品
    init(csem, 0, 0); //消费者为0
    producer()
    {
        sem_wait(&psem);//调用 -1    
        sem_post(&csem);// +1
    }
    customer()
    {
        sem_wait(&csem);
        sem_post(&psem);
    }
*/
#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
#include <stdlib.h>
#include <semaphore.h>
//创建一个互斥量
pthread_mutex_t mutex;
//创建两个信号量
sem_t psem;//生产者信号量
sem_t csem;//消费者信号量
//链表
struct Node
{
    int num;//数据
    struct Node * next;//保存下一个结点
};
//头结点
struct Node * head = NULL;
//生产者
void * producer(void * arg)
{
    //不断创建新的结点,添加到链表中
    while(1)
    {
        sem_wait(&psem);//初始量为8,  psem - 1
        pthread_mutex_lock(&mutex);
        struct Node * newNode = (struct Node *)malloc(sizeof(struct Node));//malloc一个结点转化为结构体指针类型
        newNode->next = head;//新结点指向头结点
        head = newNode;//头节点更新   头插法
        newNode->num = rand() % 1000;
        printf("add node,num: %d, itd:%ld\n",newNode->num,pthread_self());
        pthread_mutex_unlock(&mutex);
        sem_post(&csem);//csem + 1
        usleep(100);
    }
    return NULL;
}
//消费者
void * customer(void * arg)
{
    while(1)
    {
        sem_wait(&csem);//csem - 1
        pthread_mutex_lock(&mutex);
        //保存头节点的指针
        struct Node * tmp = head;
        head = head->next;
        printf("delete node, num : %d, itd %ld\n",tmp->num,pthread_self());
        free(tmp);//释放
        pthread_mutex_unlock(&mutex);
        sem_post(&psem);//psem + 1
        usleep(100);
    }
    return NULL;
}
int main()
{
    //初始化互斥量
    pthread_mutex_init(&mutex,NULL);
    //初始化信号量
    sem_init(&psem, 0, 8);
    sem_init(&csem, 0, 0);
    //创建5个生产者线程 和 5个消费者线程 容器:链表
    pthread_t ptids[5],ctids[5];
    for(int i = 0; i < 5; i++)
    {
        pthread_create(&ptids[i], NULL, producer, NULL);
        pthread_create(&ctids[i], NULL, customer, NULL);
    }
    //线程分离
    for(int i = 0; i < 5; i++)
    {
        pthread_detach(ptids[i]);
        pthread_detach(ctids[i]);
    }
    while(1)
    {
        sleep(10);//如果没有while循环 会结束互斥量 
    }
    pthread_mutex_destroy(&mutex);
    pthread_exit(NULL);//线程退出   不执行return 0; 子线程不受影响继续执行
    return 0;
}