C++11多线程之互斥量(mutex)与条件变量(condition_variable)

互斥量(std::mutex)是多线程间同时访问某一共享变量时,保证变量可被安全访问的手段。

引用 cppreference 的介绍:

1

The mutex class is a synchronization primitive that can be used to protect shared data from being simultaneously accessed by multiple threads.

锁住的代码少,这个粒度叫细,执行效率高。

锁住的代码多,这个粒度叫粗,执行效率低。

使用方法:

1:直接操作 mutex,即直接调用 mutex 的 lock/unlock 函数

try_lock() 函数是有返回值的,它表示用来尝试获取锁,如果获取成功,则返回true,如果获取失败(即锁已被其他线程获取),则返回false,这个方法无论如何都会立即返回。在拿不到锁时不会一直在那等待。

2:使用 lock_guard 自动加锁、解锁。

lock_guard是一个互斥量包装程序,它提供了一种方便的RAII(Resource acquisition is initialization )风格的机制来在作用域块的持续时间内拥有一个互斥量。

创建lock_guard对象时,它将尝试获取提供给它的互斥锁的所有权。当控制流离开lock_guard对象的作用域时,lock_guard析构并释放互斥量。

特点如下:

  • 创建即加锁,作用域结束自动析构并解锁,无需手工解锁
  • 不能中途解锁,必须等作用域结束才解锁
  • 不能复制

3:使用 unique_lock 自动加锁、解锁。

unique_lock是一个通用的互斥量锁定包装器,它允许延迟锁定,限时深度锁定,递归锁定,锁定所有权的转移以及与条件变量一起使用。

简单地讲,unique_lock 是 lock_guard 的升级加强版,它具有 lock_guard 的所有功能,同时又具有其他很多方法,使用起来更强灵活方便,能够应对更复杂的锁定需要。

特点如下:

  • 创建时可以不锁定(通过指定第二个参数为std::defer_lock),而在需要时再锁定
  • 可以随时加锁解锁
  • 作用域规则同 lock_grard,析构时自动释放锁
  • 不可复制,可移动
  • 条件变量需要该类型的锁作为参数(此时必须使用unique_lock)

注意:mutex::scoped_lock 其实就是 unique_lock 的 typedef

总结:

所有 lock_guard 能够做到的事情,都可以使用 unique_lock 做到,反之则不然。

那么何时使用lock_guard呢?很简单,

需要使用锁的时候,首先考虑使用 lock_guard
它简单、明了、易读。如果用它完全ok,就不要考虑其他了。

如果现实不允许,就让实力派 unique_lock 出马吧! 

死锁:

两个线程A、B

(a) 线程A执行的时候,这个线程先把a锁lock()成功,然后去锁b锁。线程A拿不到b锁就停在这里一直加锁

出现上下文切换

(b) 线程B执行的时候,这个线程先把b锁lock()成功,然后去锁a锁。线程B拿不到a锁就停在这里一直加锁

这时死锁就产生了。

死锁的解决方案:两个互斥量的调用顺序必须保持一致


在多线程编程中,还有另一种十分常见的行为:线程同步。线程同步是指线程间需要按照预定的先后次序顺序进行的行为。C++11对这种行为也提供了有力的支持,这就是条件变量。条件变量位于头文件condition_variable下。

条件变量提供了两类操作:wait和notify。这两类操作构成了多线程同步的基础。

(1) wait(lock): 调用时即阻塞线程,并且调用lock.unlock() 

(2) wait(lock, conditions): 调用时检查conditions,如果为false,则阻塞线程,并且调用lock.unlock(), 否则,继续执行

(3) wait_for(lock, time_duration, conditions): 调用时,检查条件是否满足:(1) conditions返回true; (2) 时间超时,如果不满足(1)(2)中的一个条件,则阻塞线程,并调用lock.unlock(), 否则,到达一定等待时间或满足条件被唤醒 ,注意,等待超过时间段后自动唤醒,判断条件一般需要使用者自己在合适的时候判断,并通过notify_one()或notify_all()唤醒,所以,使用的时候注意判断返回值,即状态是否为std::cv_status::timeout

(4) wait_until(lock, time_point, conditions): 实际wait_for是通过wait_until实现,实际上也是一样的,到达指定时间点或满足条件conditions时被唤醒,注意,到达时间点是自动唤醒,判断条件一般需要使用者自己在合适的时候判断,并通过notify_one()或notify_all()唤醒,所以,使用的时候注意判断返回值,即状态是否为std::cv_status::timeout


示例程序
条件变量和std::mutex合用,这是为了线程间通信。

#include 
#include 
#include 
#include 
#include 
 
std::mutex m;
std::condition_variable cv;
std::string data;
bool ready = false;
bool processed = false;
 
void worker_thread()
{
    // Wait until main() sends data
    std::unique_lock lk(m);
    cv.wait(lk, []{return ready;}); // 一开始,ready为false,此处会释放lock,然后在cv上阻塞等待,直到main线程通过cv.notify_xxx来唤醒当前线程,cv被唤醒后会再次对lock进行上锁,然后wait函数才会返回。wait返回后可以安全的使用mutex保护的临界区内的数据,此时mutex仍为上锁状态,故后面还需要手动释放锁
    // std::mutex mutex_;
    // std::condition_variable cv_;
    // std::unique_lock lk(mutex_);
    // cv_.wait(lk, [this] {return a_.b;});
 
    // after the wait, we own the lock.
    std::cout << "Worker thread is processing data\n";
    data += " after processing";
 
    // Send data back to main()
    processed = true;
    std::cout << "Worker thread signals data processing completed\n";
 
    // Manual unlocking is done before notifying, to avoid waking up
    // the waiting thread only to block again (see notify_one for details)
    lk.unlock();
    cv.notify_one();
}
 
int main()
{
    std::thread worker(worker_thread);
 
    data = "Example data";
    // send data to the worker thread
    {
        std::lock_guard lk(m);
        ready = true;
        std::cout << "main() signals data ready for processing\n";
    }
    cv.notify_one();
 
    // wait for the worker
    {
        std::unique_lock lk(m);
        cv.wait(lk, []{return processed;});
    }
    std::cout << "Back in main(), data = " << data << '\n';
 
    worker.join();
}

输出

main() signals data ready for processing
Worker thread is processing data
Worker thread signals data processing completed
Back in main(), data = Example data after processing

最后,总结一下条件变量的几个关键点:

1. wait()函数的内部实现是:先释放了互斥量的锁,然后阻塞以等待条件为真;
2. notify系列函数需在unlock之后再被调用;
3. 套路是:
        a. A线程拿住锁,然后wait,此时已经释放锁,只是阻塞了在等待条件为真;
        b. B线程拿住锁,做一些业务处理,然后令条件为真,释放锁,再调用notify函数;
        c. A线程被唤醒,接着运行。

参考:

https://en.cppreference.com/w/cpp/thread/condition_variable

你可能感兴趣的:(C++,多线程)