保护共享资源的方法(条件变量)

• 我最近开了几个专栏，诚信互三！
  ====> |||《算法专栏》：：刷题教程来自网站《代码随想录》。|||
  ====> |||《C++专栏》：：记录我学习C++的经历，看完你一定会有收获。|||
  ====> |||《Linux专栏》：：记录我学习Linux的经历，看完你一定会有收获。|||
  ====> |||《C#专栏》：：记录我复习C#的经历，深度理解，查漏补缺，不定期更新。|||
  ====> |||《计算机网络专栏》：：记录我学习计算机网络，看完你一定会有收获。|||

条件变量是什么

条件变量是用来保护共享资源的一种方法，是完成线程间同步的方法之一。
条件变量往往和互斥锁一起使用，这样我们就可以对共享资源进行更好的保护。

为什么要有条件变量

以生活为例，一个人要买苹果，则必须保证先要有苹果，如果买苹果的人一直问生产苹果的人，那么生产苹果的人就没时间生产苹果，买苹果的人也买不到，所以我们就需要同步，计算机也是如此。

同时，线程竞争锁的能力是不一样的，有可能存在一种情况，及在多线程并发过程中某个线程竞争锁的能力非常强，导致其他线程无法竞争到锁，导致其他线程饥饿，完成同步则可以解决线程饥饿问题。

条件变量的创建

条件变量的接口和互斥锁的接口使用起来都差不多。

pthread_cond_t类型。
和互斥锁一样，全局的可以直接使用宏初始化，非全局的需要使用接口初始化。

条件变量的初始化

pthread_cond_init(pthread_cond_t *__cond,__const pthread_condattr_t *__cond_attr)

参数1：和互斥锁一样，传入一个条件变量。
参数2：该参数可以设置条件变量的属性，一般传入nullptr。

条件变量的销毁

pthread_cond_destroy(pthread_cond_t *__cond)

参数1：传入一个条件变量，销毁。

条件变量的使用

条件变量在使用是还有一些接口。

pthread_cond_wait(pthread_cond_t *cv, pthread_mutex_t *mutex)

参数1：让该线程在那个条件变量下等待。
参数2：代表该线程等待时，释放某个锁，如果不是释放锁，那么线程将会拿着锁等待，那么该锁其他线程就永远拿不到。

此时存在一个问题，那就是在线程被唤醒后，线程从哪开始执行？
答案是从阻塞的位置开始执行，但是该线程必须继续竞争锁，拿到锁后，在能继续进行。

pthread_cond_signal(pthread_cond_t * cond)

参数1：唤醒某个条件变量下的阻塞队列中的第一个线程。

pthread_cond_brodcast(pthread_cond_t* cond)

参数1：唤醒某个条件变量下的阻塞队列中的所有线程线程。
唤醒的所有线程会竞争锁，只有竞争到的线程才会向下执行，其他线程依旧阻塞在条件变量下。

以生产消费模型为例，了解条件变量的使用

什么是生产消费模型

在对共享资源进行访问时，主要存在两种身份，及生产者（producer）和消费者（Consumer）
同时两种身份之间还有这关系。

1).生产者和生产者：互斥关系。
2).消费者和消费者：互斥关系。
3).生产者和消费者：不久互斥，还需要同步。

生产消费模型有一些特点。

1).生产消费模型的工作效率高。
2).共享资源让生产者和消费者解耦合。
3).生产消费模型支持忙闲不均。
4).生产消费模型支持良好的并发。

实现生产消费模型

阻塞队列的实现

#pragma once

#include <iostream>
#include <pthread.h>
#include <queue>
#include <vector>
#include <string>
#include <memory>
#include <unistd.h>

namespace MYqueue
{
    template <class T>
    class queue
    {
    public:
        queue(int elementnums) : _elementnums(elementnums)
        {
            pthread_mutex_init(&_mutex, nullptr);
            pthread_cond_init(&_cond, nullptr);
        }

        bool push(T &element)
        {
            // -
            pthread_mutex_lock(&_mutex);
            if (_queue.size() > _elementnums)
            {
                pthread_mutex_unlock(&_mutex);
                return false;
            }
            _queue.push(element);
            pthread_cond_signal(&_cond);
            pthread_mutex_unlock(&_mutex);
            return true;
        }

        T front()
        {
            pthread_mutex_lock(&_mutex);
            while(_queue.size() == 0) // - 防止伪唤醒，保证我一定能得到一个数据
            {
                pthread_cond_wait(&_cond, &_mutex);
            }
            T ret = _queue.front();
            _queue.pop();

            pthread_mutex_unlock(&_mutex);
            return ret;

        }

        ~queue()
        {
            pthread_mutex_destroy(&_mutex);
            pthread_cond_destroy(&_cond);
        }

    private:
        std::queue<T> _queue;
        pthread_mutex_t _mutex; // - 锁
        pthread_cond_t _cond;   // - 条件变量
        int _elementnums;
    };
}

1).push接口是生产者使用的接口，生产者之间要保证互斥，我们通过一把锁实现。
2).front接口时消费者使用的接口，消费者之间也要保证互斥，但是消费者和生产者之间也要保证互斥，所以生产者和消费者抢夺一个锁即可。
3).生产者和消费者要保证同步，我们使用条件变量来实现。

要注意，在消费者判断部分，我们要通过一个循环来防止线程被伪唤醒。

#include "queue.hpp"

using namespace MYqueue;

template <class T>
class TDate
{
public:
    TDate(char *name, queue<T> &que) : _name(name), _que(que){};

    ~TDate(){};

public:
    std::string _name;
    queue<T> &_que;
};

void *prodfunc(void *args) // - 生产者函数
{
    TDate<int> *ttd = static_cast<TDate<int> *>(args);
    int cnt = 0;
    while (true)
    {

        bool flag = ttd->_que.push(cnt);
        sleep(1);
        if (flag)
        {
            std::cout << ttd->_name << ": input success " << cnt << std::endl;
            cnt++;
        }
    }
    return nullptr;
}

void *cumerfunc(void *args)// - 消费者函数
{
    TDate<int> *ttd = static_cast<TDate<int> *>(args);
    int data = 0;
    while (true)
    {
        data = ttd->_que.front();
        sleep(1);
        std::cout << ttd->_name << ": get success is " << data << std::endl;
    }
    return nullptr;
}

void prodector(int size, std::vector<pthread_t> &proid, queue<int> &que)// - 创建生产者线程
{
    for (int i = 0; i < size; i++)
    {
        char buffer[64];
        snprintf(buffer, sizeof(buffer), "pro_thread:%d", i + 1);
        TDate<int> *td = new TDate<int>(buffer, que);
        pthread_create(&proid[i], nullptr, prodfunc, (void *)td);
    }
}

void consumer(int size, std::vector<pthread_t> &consid, queue<int> &que)// - 创建消费者线程
{
    for (int i = 0; i < size; i++)
    {
        char buffer[64];
        snprintf(buffer, sizeof(buffer), "con_thread:%d", i + 1);
        TDate<int> *td = new TDate<int>(buffer, que);
        pthread_create(&consid[i], nullptr, cumerfunc, (void *)td);
    }
}

void consjoin(std::vector<pthread_t> &consid) // - 等待消费者线程
{
    for (int i = 0; i < consid.size(); i++)
    {
        pthread_join(consid[i], nullptr);
    }
}

void prodjoin(std::vector<pthread_t> &proid)// - 等待生产者线程
{
    for (int i = 0; i < proid.size(); i++)
    {
        pthread_join(proid[i], nullptr);
    }
}

int main()
{
    queue<int> que(4);
    std::vector<pthread_t> proid(4);
    std::vector<pthread_t> consid(4);
    // printf("hehe");
    prodector(1, proid, que);
    consumer(1, consid, que);
    prodjoin(proid);
    consjoin(consid);

    return 0;
}