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

巴特西

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

最新文章

热门文章