c++多线程并发学习笔记(2)

等待一个时间或其他条件

在一个线程等待完成任务时，会有很多选择：

1. 它可以持续的检查共享数据标志（用于做保护工作的互斥量），直到另一个线程完成工作时对这个标志进行重设。缺点：资源浪费，开销大

2. 在等待线程的检查间隙，使用std::this_thread::sleep_for()进行周期性的间歇。 缺点：休眠时间抉择困难

bool flag;
std::mutex m;

void wait_for_flag()
{
  std::unique_lock<std::mutex> lk(m);
  while(!flag)
  {
    lk.unlock();  // 1 解锁互斥量
    std::this_thread::sleep_for(std::chrono::milliseconds());  // 2 休眠100ms
    lk.lock();   // 3 再锁互斥量
  }
}

3. 使用C++标准库提供的工具去等待事件的发生。通过另一线程触发等待事件的机制是最基本的唤醒方式，这种机制就称为“条件变量”。

C++标准库对条件变量有两套实现：std::condition_variable和std::condition_variable_any。这两个实现都包含在<condition_variable>头文件的声明中。两者都需要与一个互斥量一起才能工作(互斥量是为了同步)

std::condition_variable：只能与std::mutex一起工作，开销少

std::condition_variable_any：可以和任何满足最低标准的互斥量一起工作，开销大

std::condition_variable 提供两个重要的接口：notify_one()和wait()。wait()可以让线程陷入休眠状态，notify_one()就是唤醒处于wait中的其中一个条件变量（可能当时有很多条件变量都处于wait状态）。

template<typename Predicate>
wait(std::unique_lock<std::mutex>& lk, Predicate pred)

wait()会去检查这些条件(通过调用所提供的函数)，当条件满足(调用所提供的函数返回true)时返回。如果条件不满足(调用所提供的函数返回false)，wait()函数将解锁互斥量，并且将这个线程置于阻塞或等待状态。另外一个线程调用notify_one()通知条件变量时，线程从睡眠状态中苏醒，重新获取互斥锁，并且再次检查条件是否满足。

std::condition_variable::wait的一个最小化实现：

template<typename Predicate>
void minimal_wait(std::unique_lock<std::mutex>& lk,Predicate pred){
  while(!pred()){
    lk.unlock();
    lk.lock();
  }
}

考虑一个生产者消费者模型：一个线程往队列中放入数据，一个线程往队列中取数据，取数据前需要判断一下队列中确实有数据，由于这个队列是线程间共享的，所以，需要使用互斥锁进行保护，一个线程在往队列添加数据的时候，另一个线程不能取，反之亦然。用互斥锁实现如下：

#include <iostream>
#include <deque>
#include <thread>
#include <mutex>

std::deque<int> q;
std::mutex mu;

void function_1() {
    int count = ;
    while (count > ) {
        std::unique_lock<std::mutex> locker(mu);
        q.push_front(count);
        locker.unlock();
        std::this_thread::sleep_for(std::chrono::seconds());
        count--;
    }
}

void function_2() {
    int data = ;
    while ( data != ) {
        std::unique_lock<std::mutex> locker(mu);
        if (!q.empty()) {
            data = q.back();
            q.pop_back();
            locker.unlock();
            std::cout << "t2 got a value from t1: " << data << std::endl;
        } else {
            locker.unlock();
        }
    }
}
int main() {
    std::thread t1(function_1);
    std::thread t2(function_2);
    t1.join();
    t2.join();
    return ;
}

问题在于，如果生产者的速度比较慢，代码中每隔1s才会有一次数据生产，这时消费者都要去获取锁-->判断队列里是否有数据-->释放锁，这个过程就是资源的浪费，无用功使得cpu占用率很高。

使用std::this_thread::sleep_for()来对代码进行改造：

void function_2() {
    int data = ;
    while ( data != ) {
        std::unique_lock<std::mutex> locker(mu);
        if (!q.empty()) {
            data = q.back();
            q.pop_back();
            locker.unlock();
            std::cout << "t2 got a value from t1: " << data << std::endl;
        } else {
            locker.unlock();
            std::this_thread::sleep_for(std::chrono::milliseconds());
        }
    }
}

这样可以减低cpu占用率，但问题在于在实际操作中如何选择休眠时间，太长或者太短都不好。

最后可以使用条件变量来对这个代码进行改造：

#include <iostream>
#include <deque>
#include <thread>
#include <mutex>
#include <condition_variable>

std::deque<int> q;
std::mutex mu;
std::condition_variable cond;

void function_1() {
    int count = ;
    while (count > ) {
        std::unique_lock<std::mutex> locker(mu);
        q.push_front(count);
        locker.unlock();
        cond.notify_one();  // Notify one waiting thread, if there is one.
        std::this_thread::sleep_for(std::chrono::seconds());
        count--;
    }
}

void function_2() {
    int data = ;
    while ( data != ) {
        std::unique_lock<std::mutex> locker(mu);
        cond.wait(locker, [](){ return !q.empty();} );  // Unlock mu and wait to be notified
        data = q.back();
        q.pop_back();
        locker.unlock();
        std::cout << "t2 got a value from t1: " << data << std::endl;
    }
}
int main() {
    std::thread t1(function_1);
    std::thread t2(function_2);
    t1.join();
    t2.join();
    return ;
}

需要注意的几点：

在配合条件变量使用锁时，使用std::unique_lock比std::lock_guard合适，因为在wait内部有对锁的unlock和lock操作

使用细粒度锁，尽量减小锁的范围，在notify_one()的时候，不需要处于互斥锁的保护范围内，所以在唤醒条件变量之前可以将锁unlock()。

参考资料：

https://www.jianshu.com/p/c1dfa1d40f53

https://chenxiaowei.gitbook.io/c-concurrency-in-action-second-edition-2019/4.0-chinese/4.1-chinese