C++11之线程库

在 C++11 之前，涉及到多线程问题，都是和平台相关的，比如 Windows 和 Linux 下各有自己的接口，这使得代码的可移植性比较差。C++11 中最重要的特性就是对线程进行支持了，并且可以跨平台，这使得 C++ 在并行编程时不需要依赖第三方库。C++11 在原子操作中还引入了原子类的概念。

C++11 的线程库在使用上跟 Linux 中的 POSIX 线程库几乎是类似的，不过进行了类的封装。

一、std::thread

thread 类常用函数：
 ① thread()：构造一个线程对象，没有关联任何线程函数，即没有启动任何线程。
 ② thread(fn, args1, args2, ...)：构造一个线程对象，并关联线程函数 fn 。args1，args2，… 为线程函数的参数。
 ③ get_id() ：获取线程 id 。
 ④ joinable()：判断线程对象是否可以被 join 。
 ⑤ join()：阻塞等待线程对象终止。
 ⑥ detach()：分离线程对象。

注：
 ① 线程函数是可调用对象，可按照以下三种方式提供：函数指针、lambda表达式、函数对象。
 ② thread 类不允许拷贝构造以及赋值重载，但是可以移动构造和移动赋值（将一个线程对象关联线程的状态转移给其他线程对象，转移期间不影响线程的执行）。
 ③ 可以通过joinable()函数判断线程是否是有效的，如果是，则线程无效。
 ④ 采用默认构造函数构造的线程对象。
 ⑤ 线程对象的状态已经转移给其他线程对象。
 ⑥ 线程已经被 join 或者 detach 了。

在某些场景下，我们需要在线程函数内部对外部实参做修改，有两种解决方案。

解决方案1：使用老方法，传指针给线程函数

#include <iostream>
#include <thread>
using namespace std;

void func(int* p)
{
    cout << "p:" << p << endl;
    (*p) += 10;
}

int main()
{
    int n = 0;
    cout << "&n: " << &n << endl;
    thread t1(func, &n);
    t1.join();

    cout << n << endl;

    return 0;
}

运行结果：n 和 p 的地址相同，n 的值是 10 。

解决方案2：传引用给线程函数，但是需要注意的是，必须使用std::ref()来指明实参是引用类型（否则会报错）。

在一般情况下，传引用传参不需要使用std::ref()来特别指明，但在线程函数中传引用传参时需要，这跟线程函数的底层实现有关。

#include <iostream>
#include <thread>
using namespace std;

void func(int& x)
{
    cout << "&x:" << &x << endl;
    x += 10;
}

int main()
{
    int n = 0;
    cout << "&n: " << &n << endl;
    thread t1(func, std::ref(n));
    t1.join();

    cout << n << endl;

    return 0;
}

二、std::mutex

在 C++11 中，mutex 总共包含四种互斥锁。但我们最常用的还是 mutex 。

mutex 类常用函数：
 ① lock()：加互斥锁（若线程申请锁成功，继续向后执行；若申请锁不成功，会被挂起等待）。
 ② unlock()：解互斥锁。
 ③ try_lock()：尝试加互斥锁，若互斥锁被其他线程占有，则当前线程立即返回（即相比于lock()，try_lock()是非阻塞的）。

我们给临界区加互斥锁，一般情况下，临界区的范围越小越好。

但下面的测试代码是一个极端场景：

#include <iostream>
#include <thread>
#include <mutex>
using namespace std;

int x = 0;  //两个线程对同一个变量x++,共享变量
mutex mtx;

int main()
{
    thread t1(Func, 50000000);
    thread t2(Func, 50000000);

    t1.join();
    t2.join();

    cout << x << endl;

    return 0;
}

//把加锁和解锁放在循环的外面
void Func(int n)
{
    mtx.lock();
    for (int i = 0; i < n; ++i)
    {
        ++x;
    }
    mtx.unlock();
}

//把加锁和解锁放在循环的里面
void Func(int n)
{
    for (int i = 0; i < n; ++i)
    {
        mtx.lock();
        ++x;
        mtx.unlock();
    }
}

在这个例子中，在保证线程安全的前提下，把加锁和解锁放在循环的里面和外面均可。
不过在这里最好放在循环的外面，因为放在循环的里面会带来效率的降低。可以亲自测试一下。

主要是因为循环里面的代码执行得快（++x 很快），而且锁的申请和释放也有消耗。

• 若把加锁和解锁放在循环的外面，在这种情况下虽然多个线程是串行执行的。
• 若把加锁和解锁放在循环的里面，在这种情况下虽然多个线程是并行执行的，但是由于频繁地申请锁和释放锁，频繁地切换上下文，会带来很大的消耗，于是带来效率的降低，反而还不如多线程串行执行。如果把加锁和解锁放在循环的里面，相比于互斥锁，使用自旋锁更好。

三、lock_guard 与 unique_lock

下面的代码在极端情况下会出现死锁问题：

//这是多线程场景，func是所有线程的执行函数
void func(vector<int>& v, int n, int base, mutex& mtx)
{
    try
    {
        for (int i = 0; i < n; ++i)
        {
            mtx.lock();

            v.push_back(base + i);

            mtx.unlock();
        }
    }
    catch(const exception& e)
    {
        cout << e.what() << endl;
    }
}

push_back()在插入数据时有可能因为空间不够而需要扩容，就向系统申请空间，申请空间失败会抛异常。代码在push_back()处抛异常，不会执行unlock()，线程还未释放锁，进而导致死锁问题，这是一种异常安全问题。

实际上，指针变量会交给智能指针来管理，而锁会交给 lock_guard 或 unique_lock 来管理，创建对象来对资源进行管理，对象出了作用域就会调用析构函数来释放资源，于是我们就不需要在 catch 块中考虑诸如解锁和释放内存等问题了。

C++11 采用 RAII 的方式对锁进行了封装，即 lock_guard 与 unique_lock 。

3.1 lock_guard

lock_guard 的成员函数只有构造函数和析构函数。

• lock_guard 在创建对象时，会在构造函数中调用lock()。
• 在销毁对象时，会在析构函数中调用unlock()。

下面是对应的代码：

//这是多线程场景，func是所有线程的执行函数
void func(vector<int>& v, int n, int base, mutex& mtx)
{
    try
    {
        for (int i = 0; i < n; ++i)
        {
            lock_guard<mutex> lock(mtx);  //lock_guard，不会导致死锁

            cout << this_thread::get_id() << ":" << base + i << endl;

            v.push_back(base + i);

            if (base == 1000 && i == 888)  //模拟push_back失败抛异常
            {
                throw bad_alloc();
            }
        }
    }
    catch (const exception& e)
    {
        cout << e.what() << endl;
    }
}

template<class Lock>
class LockGuard    //我们简单模拟实现的lock_guard
{
public:
    LockGuard(Lock& lock)  //引用类型
        :_lock(lock)
    {
        _lock.lock();
    }

    ~LockGuard()
    {
        _lock.unlock();
    }

    //防止拷贝和赋值
    LockGuard(const LockGuard&) = delete;
    LockGuard& operator=(const LockGuard&) = delete;

private:
    Lock& _lock;  //引用类型
};

3.2  unique_lock

由于 lock_guard 比较单一，没有办法对锁进行控制，因此 C++11 又提供了 unique_lock 。

unique_lock 跟 lock_guard 类似，可以用 unique_lock 替换掉 lock_guard 。
但相比于 lock_guard ，unique_lock 更加的灵活，提供了更多的成员函数。

四、atomic

在 C++11 中，如果想要在多线程环境下保证某个共享变量的安全性，除了加互斥锁以外，我们还可以把共享变量的类型定义为原子类型。

由于对原子类型变量的操作本身就是原子的，所以是线程安全的。

测试代码：

#include <iostream>
#include <thread>
#include <mutex>
#include <atomic>
using namespace std;

atomic<int> x = 0;

void Func(int n)
{
    for (int i = 0; i < n; ++i)
    {
        ++x;  //原子操作的++
    }
}

int main()
{
    thread t1(Func, 50000000);
    thread t2(Func, 50000000);

    t1.join();
    t2.join();

    cout << x << endl;

    return 0;
}

五、condition_variable

 实现一个程序，使得两个线程交替打印，一个打印奇数，一个打印偶数。

只使用互斥锁是不满足题目要求的。
比如下面的代码：

#include <iostream>
#include <thread>
#include <mutex>
using namespace std;

int main()
{
    int n = 100;
    int i = 0;
    mutex mtx;

    //偶数 - 先打印
    thread t1([n, &i, &mtx]{
        while (i < n)
        {
            unique_lock<mutex> lock(mtx);

            cout << this_thread::get_id() << ":" << i << endl;
            ++i;
        }
    });

    //交替走

    //奇数 - 后打印
    thread t2([n, &i, &mtx]{
        while (i < n)
        {
            unique_lock<mutex> lock(mtx);

            cout << this_thread::get_id() << ":" << i << endl;
            ++i;
        }
    });

    t1.join();
    t2.join();

    return 0;
}

虽然运行结果看上去满足了题目要求，但是也不能排除其中一个线程的时间片比较充足，连续打印了好几次。换言之，上面的程序不能保证一定能满足题目要求。

为了保证一定能够满足题目要求，两个线程交替打印时必须具备一定的顺序性，即线程同步。因此，其中一种方法，就是使用条件变量。

5.1 condition_variable 介绍 [ 线程间同步通信，condition_variable 对象+unique_lock 对象 ]

condition_variable 是 C++ 中的一种同步工具, 可以在线程间进行同步通信。它主要由两部分组成:

• 一个 condition_variable 对象
• 一个 unique_lock 对象

5.2 使用方法 [wait()+ notify_one() / notify_all() ]

当某个线程需要等待某个条件成立时, 它会对 condition_variable 调用 wait() 方法, 这样它就会被阻塞直到其他线程通知它, 或者其他线程调用了notify_one() 或 notify_all() 方法。

当其他线程改变了某个条件, 想要通知等待中的线程时, 它会调用 notify_one() 或 notify_all() 方法, 这样等待线程就可以被唤醒。这样就可以避免了使用传统的等待方式（例如while 循环或者 sleep() ）带来的资源浪费和程序降低可维护性问题。

请注意，在使用condition_variable 时需要使用unique_lock作为其辅助，因为 condition_variable 实现对于解锁，锁定，配对操作。

notify_one() 作用是唤醒一个正在等待 condition_variable 的线程，使其获得锁并继续执行。它只会唤醒一个等待的线程，所以如果有多个线程在等待，那么只有一个线程会被唤醒，其他线程还是处于等待状态。使用 notify_one() 的方法是：

1. 在线程中使用 std::unique_lock 对象来锁定 condition_variable，
2. 然后调用 condition_variable 的 wait() 方法来等待，
3. 当线程需要唤醒其他线程时，调用 notify_one() 来唤醒等待的线程。

condition_variable 类常用函数：

 ① wait(lck)：在条件变量下等待（调用时，会首先自动释放互斥锁，然后再挂起自己；被唤醒时，会自动竞争锁，获取到锁之后才能返回）。
 ② wait(lck, pred)：pred 是可调用对象，相当于 while (!pred()) wait(lck); 。
 ③ notify_one()：唤醒在条件变量下等待的一个线程。
 ④ notify_all()：唤醒在条件变量下等待的所有线程。

通过使用条件变量，能够实现一个一定能够满足题目要求的程序。
比如下面的代码：

#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>
using namespace std;

int main()
{
    int n = 100;
    int i = 0;
    mutex mtx;
    condition_variable cv;
    bool flag = false;

    //偶数 - 先打印
    thread t1([n, &i, &mtx, &cv, &flag]{
        while (i < n)
        {
            unique_lock<mutex> lock(mtx);

            //若flag为true，会wait，直到flag为false
            cv.wait(lock, [&flag]()->bool {return !flag; });

            cout << this_thread::get_id() << "->:" << i << endl;
            ++i;
            //保证下一个打印的一定是另一个线程，也可以防止该线程连续打印
            flag = true;

            cv.notify_one();
        }
    });

    //奇数 - 后打印
    thread t2([n, &i, &mtx, &cv, &flag]{
        while (i < n)
        {
            unique_lock<mutex> lock(mtx);

            //若flag为false，会wait，直到flag为true
            cv.wait(lock, [&flag]()->bool {return flag; });

            cout << this_thread::get_id() << ":->" << i << endl;
            ++i;
            //保证下一个打印的一定是另一个线程，也可以防止该线程连续打印
            flag = false;

            cv.notify_one();
        }
    });

    t1.join();
    t2.join();

    return 0;
}

————————————————
版权声明：本文为CSDN博主「Butayarou」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/m0_59938453/article/details/128435077