C++11新特性——互斥锁、条件变量、原子类型

最新推荐文章于 2024-05-04 11:07:08 发布

is-zq

最新推荐文章于 2024-05-04 11:07:08 发布

阅读量2.1k

点赞数 5

分类专栏： C++ 文章标签： c++ 开发语言

本文链接：https://blog.csdn.net/m0_67168421/article/details/128302838

版权

C++ 专栏收录该内容

18 篇文章 0 订阅

订阅专栏

1、互斥锁

C++11提供了四种互斥锁：

mutex：互斥锁。
timed_mutex：带超时机制的互斥锁。
recursive_mutex：递归互斥锁。
recursive_timed_mutex：带超时机制的递归互斥锁。

包含头文件：#include <mutex>

一、mutex类

1）加锁lock()

互斥锁有锁定和未锁定两种状态。

如果互斥锁是未锁定状态，调用lock()成员函数的线程会得到互斥锁的所有权，并将其上锁。

如果互斥锁是锁定状态，调用lock()成员函数的线程就会阻塞等待，直到互斥锁变成未锁定状态。

2）解锁unlock()

只有持有锁的线程才能解锁。

3）尝试加锁try_lock()

如果互斥锁是未锁定状态，则加锁成功，函数返回true。

如果互斥锁是锁定状态，则加锁失败，函数立即返回false。（线程不会阻塞等待）

示例：

#include <iostream>
#include <thread>                // 线程类头文件。
#include <mutex>                // 互斥锁类的头文件。
using namespace std;

mutex mtx;        // 创建互斥锁，保护共享资源cout对象。

// 普通函数。
void func(int bh, const string& str) {
      for (int ii = 1; ii <= 10; ii++)
      {
            mtx.lock();      // 申请加锁。
            cout << bh << str << endl;
            mtx.unlock();  // 解锁。
            this_thread::sleep_for(chrono::seconds(1));     // 休眠1秒。
      }
}

int main()
{
      // 用普通函数创建线程。
      thread t1(func, 1, "我是一只傻傻鸟。");
      thread t2(func, 2, "我是一只傻傻鸟。");
      thread t3(func, 3, "我是一只傻傻鸟。");
      thread t4(func, 4, "我是一只傻傻鸟。");
      thread t5(func, 5, "我是一只傻傻鸟。");

      t1.join();         // 回收线程t1的资源。
      t2.join();         // 回收线程t2的资源。
      t3.join();         // 回收线程t3的资源。
      t4.join();         // 回收线程t4的资源。
      t5.join();         // 回收线程t5的资源。
      return 0;
}

二、timed_mutex类

增加了两个成员函数：

bool try_lock_for(时间长度);

bool try_lock_until(时间点);

三、recursive_mutex类

递归互斥锁允许同一线程多次获得互斥锁，可以解决同一线程多次加锁造成的死锁问题。

示例：

#include <iostream>
#include <mutex>        // 互斥锁类的头文件。
using namespace std;

class AA
{
      recursive_mutex m_mutex;
public:
      void func1() {
            m_mutex.lock();
            cout << "调用了func1()\n";
            m_mutex.unlock();
      }

      void func2() {
            m_mutex.lock();
            cout << "调用了func2()\n";
            func1();
            m_mutex.unlock();
      }
};

int main()
{
      AA aa;
      //aa.func1();
      aa.func2();
      return 0;
}

四、lock_guard类

lock_guard是模板类，可以简化互斥锁的使用，也更安全。

lock_guard的定义如下：

template<class Mutex>

class lock_guard

{

explicit lock_guard(Mutex& mtx);

}

lock_guard在构造函数中加锁，在析构函数中解锁。

lock_guard采用了RAII思想（在类构造函数中分配资源，在析构函数中释放资源，保证资源在离开作用域时自动释放）。

2、条件变量-生产消费者模型

条件变量是一种线程同步机制。当条件不满足时，相关线程被一直阻塞，直到某种条件出现，这些线程才会被唤醒。

C++11的条件变量提供了两个类：

condition_variable：只支持与普通mutex搭配，效率更高。

condition_variable_any：是一种通用的条件变量，可以与任意mutex搭配（包括用户自定义的锁类型）。

包含头文件：<condition_variable>

一、condition_variable类

主要成员函数：

1）condition_variable() 默认构造函数。

2）condition_variable(const condition_variable &)=delete 禁止拷贝。

3）condition_variable& condition_variable::operator=(const condition_variable &)=delete 禁止赋值。

4）notify_one() 通知一个等待的线程。

5）notify_all() 通知全部等待的线程。

6）wait(unique_lock<mutex> lock) 阻塞当前线程，直到通知到达。

7）wait(unique_lock<mutex> lock,Pred pred) 循环的阻塞当前线程，直到通知到达且谓词满足。

8）wait_for(unique_lock<mutex> lock,时间长度)

9）wait_for(unique_lock<mutex> lock,时间长度,Pred pred)

10）wait_until(unique_lock<mutex> lock,时间点)

11）wait_until(unique_lock<mutex> lock,时间点,Pred pred)

二、unique_lock类

template <class Mutex> class unique_lock是模板类，模板参数为互斥锁类型。

unique_lock和lock_guard都是管理锁的辅助类，都是RAII风格（在构造时获得锁，在析构时释放锁）。它们的区别在于：为了配合condition_variable，unique_lock还有lock()和unlock()成员函数。

示例1：

#include <iostream>
#include <string>
#include <thread>                      // 线程类头文件。
#include <mutex>                      // 互斥锁类的头文件。
#include <deque>                      // deque容器的头文件。
#include <queue>                      // queue容器的头文件。
#include <condition_variable>  // 条件变量的头文件。
using namespace std;

class AA
{
    mutex m_mutex;                                    // 互斥锁。
    condition_variable m_cond;                  // 条件变量。
    queue<string, deque<string>> m_q;   // 缓存队列，底层容器用deque。
public:
    void incache(int num)     // 生产数据，num指定数据的个数。
    {
        lock_guard<mutex> lock(m_mutex);   // 申请加锁。
        for (int ii=0 ; ii<num ; ii++)
        {
            static int bh = 1;           // 编号。
            string message = to_string(bh++) + "号";    // 拼接出一个数据。
            m_q.push(message);     // 把生产出来的数据入队。
        }
        m_cond.notify_one();     // 唤醒一个被当前条件变量阻塞的线程。
    }

    void outcache()       // 消费者线程任务函数。
    {
        while (true)
        {
            string message;
            {
                // 把互斥锁转换成unique_lock<mutex>，并申请加锁。
                unique_lock<mutex> lock(m_mutex);

                while (m_q.empty())    // 如果队列空，进入循环，否则直接处理数据。必须用循环，不能用if
                    m_cond.wait(lock);  // 等待生产者的唤醒信号。

                // 数据元素出队。
                message = m_q.front();  m_q.pop();
            }//出了该代码块后自动解锁
            // 处理出队的数据（把数据消费掉）。
            this_thread::sleep_for(chrono::milliseconds(1));   // 假设处理数据需要1毫秒。
            cout << "线程：" << this_thread::get_id() << "，" << message << endl;
        }
    }
};

int main()
{
    AA aa;

    thread t1(&AA::outcache, &aa);     // 创建消费者线程t1。
    thread t2(&AA::outcache, &aa);     // 创建消费者线程t2。
    thread t3(&AA::outcache, &aa);     // 创建消费者线程t3。

    this_thread::sleep_for(chrono::seconds(2));    // 休眠2秒。
    aa.incache(3);      // 生产3个数据。

    this_thread::sleep_for(chrono::seconds(3));    // 休眠3秒。
    aa.incache(5);      // 生产5个数据。

    t1.join();   // 回收子线程的资源。
    t2.join();
    t3.join();
    return 0;
}

示例2：

#include <iostream>
#include <string>
#include <thread>                      // 线程类头文件。
#include <mutex>                      // 互斥锁类的头文件。
#include <deque>                      // deque容器的头文件。
#include <queue>                      // queue容器的头文件。
#include <condition_variable>  // 条件变量的头文件。
using namespace std;

class AA
{
    mutex m_mutex;                                    // 互斥锁。
    condition_variable m_cond;                  // 条件变量。
    queue<string, deque<string>> m_q;   // 缓存队列，底层容器用deque。
public:
    void incache(int num)     // 生产数据，num指定数据的个数。
    {
        lock_guard<mutex> lock(m_mutex);   // 申请加锁。
        for (int ii=0 ; ii<num ; ii++)
        {
            static int bh = 1;           // 编号。
            string message = to_string(bh++) + "号";    // 拼接出一个数据。
            m_q.push(message);     // 把生产出来的数据入队。
        }
        //m_cond.notify_one();     // 唤醒一个被当前条件变量阻塞的线程。
        m_cond.notify_all();          // 唤醒全部被当前条件变量阻塞的线程。
    }

    void outcache()   {    // 消费者线程任务函数。
        while (true)   {
            // 把互斥锁转换成unique_lock<mutex>，并申请加锁。
            unique_lock<mutex> lock(m_mutex);

            // 条件变量虚假唤醒：消费者线程被唤醒后，缓存队列中没有数据。
            //while (m_q.empty())    // 如果队列空，进入循环，否则直接处理数据。必须用循环，不能用if
            //    m_cond.wait(lock);  // 1）把互斥锁解开；2）阻塞，等待被唤醒；3）给互斥锁加锁。
            m_cond.wait(lock, [this] { return !m_q.empty(); });

            // 数据元素出队。
            string message = m_q.front();  m_q.pop();
            cout << "线程：" << this_thread::get_id() << "，" << message << endl;
            lock.unlock();      // 手工解锁。

            // 处理出队的数据（把数据消费掉）。
            this_thread::sleep_for(chrono::milliseconds(1));   // 假设处理数据需要1毫秒。
        }
    }
};

int main()
{
    AA aa;

    thread t1(&AA::outcache, &aa);     // 创建消费者线程t1。
    thread t2(&AA::outcache, &aa);     // 创建消费者线程t2。
    thread t3(&AA::outcache, &aa);     // 创建消费者线程t3。

    this_thread::sleep_for(chrono::seconds(2));    // 休眠2秒。
    aa.incache(2);      // 生产2个数据。

    this_thread::sleep_for(chrono::seconds(3));    // 休眠3秒。
    aa.incache(5);      // 生产5个数据。

    t1.join();   // 回收子线程的资源。
    t2.join();
    t3.join();
    return 0;
}

244、原子类型atomic

C++11提供了atomic<T>模板类（结构体），用于支持原子类型，模板参数可以是bool、char、int、long、long long、指针类型（不支持浮点类型和自定义数据类型）。

原子操作由CPU指令提供支持，它的性能比锁和消息传递更高，并且，不需要程序员处理加锁和释放锁的问题，支持修改、读取、交换、比较并交换等操作。

头文件：#include <atomic>

构造函数：

atomic() noexcept = default; // 默认构造函数。

atomic(T val) noexcept; // 转换函数。

atomic(const atomic&) = delete; // 禁用拷贝构造函数。

赋值函数：

atomic& operator=(const atomic&) = delete; // 禁用赋值函数。

常用函数：

void store(const T val) noexcept; // 把val的值存入原子变量。

T load() noexcept; // 读取原子变量的值。

T fetch_add(const T val) noexcept; // 把原子变量的值与val相加，返回原值。

T fetch_sub(const T val) noexcept; // 把原子变量的值减val，返回原值。

T exchange(const T val) noexcept; // 把val的值存入原子变量，返回原值。

T compare_exchange_strong(T &expect,const T val) noexcept; // 比较原子变量的值和预期值expect，如果当两个值相等，把val存储到原子变量中，函数返回true；如果当两个值不相等，用原子变量的值更新预期值，函数返回false。CAS指令。

bool is_lock_free(); // 查询某原子类型的操作是直接用CPU指令（返回true），还是编译器内部的锁（返回false）。

原子类型的别名：

注意：

atomic<T>模板类重载了整数操作的各种运算符。
atomic<T>模板类的模板参数支持指针，但不表示它所指向的对象是原子类型。
原子整型可以用作计数器，布尔型可以用作开关。
CAS指令是实现无锁队列基础。

示例：

#include <iostream>
#include <atomic>     // 原子类型的头文件。
using namespace std;

int main()
{
      atomic<int> a = 3;       // atomic(T val) noexcept;  // 转换函数。
      cout << "a=" << a.load() << endl;   // 读取原子变量a的值。输出：a=3
      a.store(8);      // 把8存储到原子变量中。
      cout << "a=" << a.load() << endl;   // 读取原子变量a的值。 输出：a=8

      int old;        // 用于存放原值。
      old = a.fetch_add(5);         // 把原子变量a的值与5相加，返回原值。
      cout << "old = " << old <<"，a = " << a.load() << endl;   // 输出：old=8，a=13
      old = a.fetch_sub(2);         // 把原子变量a的值减2，返回原值。
      cout << "old = " << old << "，a = " << a.load() << endl;   // 输出：old=13，a=11

      atomic<int> ii = 3;  // 原子变量
      int expect = 4;         // 期待值
      int val = 5;               // 打算存入原子变量的值
      // 比较原子变量的值和预期值expect，
      // 如果当两个值相等，把val存储到原子变量中；
      // 如果当两个值不相等，用原子变量的值更新预期值。
      // 执行存储操作时返回true，否则返回false。
      bool bret = ii.compare_exchange_strong(expect, val);
      cout << "bret=" << bret << endl;
      cout << "ii=" << ii << endl;
      cout << "expect=" << expect << endl;
      return 0;
}