【Linux】生产者和消费者模型、条件变量、信号量

橙色

生产者和消费者模型

生产者和消费是操作系统中一种重要的模型，它描述的是一种等待和通知的机制。

具体可观看该文章：生产者和消费者模型

互斥锁

互斥锁是用一种简单的方法控制线程对共享资源的操作。在某种意义上可以将互斥锁看成一个全局变量，即可简单理解为某一时刻只能被一个线程所操作。
互斥锁有两种状态：上锁和解锁。

• 在某一时刻只能有一个线程掌握着互斥。
• 掌握着互斥锁的线程可以对共享资源进行操作
• 若其他线程想要上锁一个已经被上锁的互斥锁，该线程就会被挂起，等到已上锁的线程释放掉互斥锁为止。
• 互斥锁保证了每个线程按顺序对共享资源进行操作。

pthread_mutex_init (pthread_mutex_t *_mutex,const pthread_mutex_t *mutexatter)
初始化互斥锁函数
第一个参数mutex是只想要初始化的互斥锁的指针
第二个参数mutex是指向属性对象的指针，定义的是初始化互斥锁的属性，一般为NULL，即默认属性。
此外，也可以用宏PTHREAD_MUTEX_INTIALIZER 初始化静态分配的互斥锁。

pthread_mutex_destroy (pthread_mutex_t *mutex)
锁毁互斥锁函数
参数为指向互斥锁的指针
当这两个函数成功完成时返回0.否则返回错误编号指明错误。

int pthread_mutex_lock(pthread_mutex_t *mutex);
以阻塞的方式申请互斥锁
int pthread_mutex_trylock(pthread_mutex_t *mutex);
以非阻塞的方式申请互斥锁

pthread_mutex_unlock(pthread_mutex_t *mutex)
释放互斥锁
释放操作只能由占有该互斥锁的线程完成。

条件变量

函数解析

条件变量不是锁，条件变量可以使线程在满足某个条件以后，阻塞或者解除阻塞

/*
    条件变量的类型 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);
        - 唤醒所有的等待的线程
*/

代码举例

第58行为什么要引入条件变量呢？因为单纯依靠互斥锁的话，如果一直没有节点被生产出来且容器中节点为0，那么消费者子线程就会一直进行死循环，这无疑是极其浪费资源的。所以比较好的做法就是当没有节点的时候，消费者去通知生产者来生产节点。
第32行用pthread_cond_signal还是pthread_cond_signal都是可以的
第58行pthread_cond_wait(&cond, &mutex)，当消费者子线程阻塞在这里时，第23行pthread_mutex_lock(&mutex)，生产者子线程还能拿到锁吗？不能的话岂不是陷入死锁了？其实不是这样的，当消费者子线程阻塞在这里时，wait会对mutex互斥锁进行一个解锁的操作，使得该锁可以被拿。但要注意的是当wait解除阻塞的时候就又会把mutex锁加上，所以在下面需要有一个解锁的操作

#include <stdio.h>
#include <pthread.h>
#include <stdlib.h>
#include <unistd.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));
        //这里用的是头插法，把新生成的节点插到了链表的最前面
        newNode->next = head;
        head = newNode;
        newNode->num = rand() % 1000;//成一个介于0到999之间的随机整数
        printf("add node, num : %d, tid : %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("del node, num : %d, tid : %ld\n", tmp->num, pthread_self());
            free(tmp);
            pthread_mutex_unlock(&mutex);
            usleep(100);
        } else {
            // 没有数据，需要等待
            // 当这个函数调用阻塞的时候，会对互斥锁进行解锁，当不阻塞的，继续向下执行，会重新加锁。
            pthread_cond_wait(&cond, &mutex);
            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)死循环主要是防止上面的子线程刚一创建好，下面就把互斥锁和条件变量给销毁了
    while(1) {
        sleep(10);
    }

    pthread_mutex_destroy(&mutex);
    pthread_cond_destroy(&cond);

	//这里调用pthread_exit()函数，使得主线程结束而子线程不会结束，且后面的return 0也不会执行
    pthread_exit(NULL);

    return 0;
}

运行结果：

1、消费者和生产者这种模型下，生产者和消费者是使用同一把锁的。因为只要是多个线程操作相同的一份数据，就需要保证代码同步。


2、问：如果容器中的数据足够多，消费者不执行pthread_cond_wait(&cond,&mutex)
那么生产者中的pthread_cond_signal(&cond)信号通知给谁，或者信号哪了？
    答：signal是唤醒一个或者多个睡眠的线程，如果数据足够多，线程没有休眠，即使收到了信号也不会做任何的处理。《Liunx/UNIX系统编程手册》第531页有句话，条件变量并不保存状态信息，只是传递应用程序状态信息的一种通讯机制。发送信号时若无任何线程在等待该条件变量，这个也就会不了了之。线程如在此后等待该条件变量，只有当再次收到此变量的下一信号时，方可解除阻塞状态。


3、问：当消费者执行到pthread_cond_wait对mutex进行了解锁，那么这个时候其他消费者线程会不会抢先对mutex进行加锁，从而导致生产者无法正常生产呢？
    答： 其他消费者也在pthread_cond_wait等待

信号量

函数解析

/*
    信号量的类型 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);
    init(csem, 0, 0);

    producer() {
        sem_wait(&psem);
        sem_post(&csem)
    }

    customer() {
        sem_wait(&csem);    //当csem信号量不为0时，减一；为0时，就堵塞在这里
        sem_post(&psem)
    }

*/

代码举例

这里是引用

#include <stdio.h>
#include <pthread.h>
#include <stdlib.h>
#include <unistd.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);
        pthread_mutex_lock(&mutex);
        struct Node * newNode = (struct Node *)malloc(sizeof(struct Node));
        newNode->next = head;
        head = newNode;
        newNode->num = rand() % 1000;
        printf("add node, num : %d, tid : %ld\n", newNode->num, pthread_self());
        pthread_mutex_unlock(&mutex);
        sem_post(&csem);
    }

    return NULL;
}

void * customer(void * arg) {

    while(1) {
        sem_wait(&csem);
        pthread_mutex_lock(&mutex);
        // 保存头结点的指针
        struct Node * tmp = head;
        head = head->next;
        printf("del node, num : %d, tid : %ld\n", tmp->num, pthread_self());
        free(tmp);
        pthread_mutex_unlock(&mutex);
        sem_post(&psem);
       
    }
    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);
    }

    pthread_mutex_destroy(&mutex);

    pthread_exit(NULL);

    return 0;
}

因为使用的是头插法，所以最后加入链表的最先被打印出来。
信号量的大小决定了容器的容量