编程总结（二）C++11中的多线程

编程总结（二）C++11中的多线程

一、前言

以下内容来自互联网以及笔者的总结。

二、thread

#include <iostream>
#include <thread>
using namespace std;
void testFun1()
{
    cout << "普通函数" << endl;
}
class MyClass
{
public:
    void testFun2(string s)
    {
        cout << s.c_str() << endl;
    }
};
int main(void)
{
    thread t1(testFun1);
    t1.join();//当前线程运行完后，才会继续主线程
    MyClass ms;
    thread t2(&MyClass::testFun2, ms, "这是类成员非静态函数作为线程函数,而且是带有参数的线程函数");
    t2.detach();//作为后台线程运行，即与主线程运行没有关系了
    //输出线程id和cpu核数
    cout << "ID:" << t1.get_id() << endl;
    cout << "CPU:" << thread::hardware_concurrency() << endl;
    getchar();
    return 0;
}

• std::thread::thread()，构造函数，用于创建线程。
• 线程的复制构造函数被禁用
• move,可以使一个线程移动到另外一个线程，原线程不存在了（不太准确的说法）
• std::thread::join()，用于等待线程运行结束。
• std::thread::detach()，用于让线程不受句柄控制。
• std::thread::swap()，用于交换两个线程。
• std::thread::get_id()，用于获得线程ID号。
• std::thread::joinable()，用于判断线程是否可等待。
• std::thread::native_handle()，用于获得与操作系统相关的原生线程句柄。

若线程函数为类成员非静态函数，则构造thread时，第一个参数为函数地址，第二个参数为该类实例的一个引用或者指针，后面的参数为线程函数参数。

三、mutex

Mutex 系列类(四种)

• std::mutex，最基本的 Mutex 类。
• std::recursive_mutex，递归 Mutex 类。
• std::time_mutex，定时 Mutex 类。
• std::recursive_timed_mutex，定时递归 Mutex 类。

Lock 类（两种）

• std::lock_guard，与 Mutex RAII 相关，方便线程对互斥量上锁。
• std::unique_lock，与 Mutex RAII 相关，方便线程对互斥量上锁，但提供了更好的上锁和解锁控制。

其他类型

• std::once_flag
• std::adopt_lock_t
• std::defer_lock_t
• std::try_to_lock_t

函数

• std::try_lock，尝试同时对多个互斥量上锁。
• std::lock，可以同时对多个互斥量上锁。
• std::call_once，如果多个线程需要同时调用某个函数，call_once 可以保证多个线程对该函数只调用一次。

1、mutex
std::mutex 是C++11 中最基本的互斥量，std::mutex 对象提供了独占所有权的特性——即不支持递归地对 std::mutex 对象上锁
std::mutex 的成员函数

• 构造函数，std::mutex不允许拷贝构造，也不允许 move 拷贝，最初产生的 mutex 对象是处于 unlocked 状态的。
• lock()，调用线程将锁住该互斥量。线程调用该函数会发生下面 3 种情况：(1). 如果该互斥量当前没有被锁住，则调用线程将该互斥量锁住，直到调用 unlock之前，该线程一直拥有该锁。(2). 如果当前互斥量被其他线程锁住，则当前的调用线程被阻塞住。(3). 如果当前互斥量被当前调用线程锁住，则会产生死锁(deadlock)。
• unlock()， 解锁，释放对互斥量的所有权。
• try_lock()，尝试锁住互斥量，如果互斥量被其他线程占有，则当前线程也不会被阻塞。线程调用该函数也会出现下面 3 种情况，(1). 如果当前互斥量没有被其他线程占有，则该线程锁住互斥量，直到该线程调用 unlock 释放互斥量。(2). 如果当前互斥量被其他线程锁住，则当前调用线程返回 false，而并不会被阻塞掉。(3). 如果当前互斥量被当前调用线程锁住，则会产生死锁(deadlock)。

2、std::recursive_mutex
std::recursive_mutex 与 std::mutex 一样，也是一种可以被上锁的对象，但是和 std::mutex 不同的是，std::recursive_mutex 允许同一个线程对互斥量多次上锁（即递归上锁），来获得对互斥量对象的多层所有权，std::recursive_mutex 释放互斥量时需要调用与该锁层次深度相同次数的 unlock()，可理解为 lock() 次数和 unlock() 次数相同，除此之外，std::recursive_mutex 的特性和 std::mutex 大致相同。

2、std::time_mutex

std::time_mutex 比 std::mutex 多了两个成员函数，

• try_lock_for 函数接受一个时间范围，表示在这一段时间范围之内线程如果没有获得锁则被阻塞住（与 std::mutex 的 try_lock() 不同，try_lock 如果被调用时没有获得锁则直接返回 false），如果在此期间其他线程释放了锁，则该线程可以获得对互斥量的锁，如果超时（即在指定时间内还是没有获得锁），则返回 false。

• try_lock_until 函数则接受一个时间点作为参数，在指定时间点未到来之前线程如果没有获得锁则被阻塞住，如果在此期间其他线程释放了锁，则该线程可以获得对互斥量的锁，如果超时（即在指定时间内还是没有获得锁），则返回 false。

3、std::recursive_timed_mutex
可递归的时间互斥量

4、Mutex RAII

RAII是Resource Acquisition Is Initialization的简称，是C++语言的一种管理资源、避免泄漏的惯用法。利用的就是C++构造的对象最终会被销毁的原则。RAII的做法是使用一个对象，在其构造时获取对应的资源，在对象生命期内控制对资源的访问，使之始终保持有效，最后在对象析构的时候，释放构造时获取的资源。

实际意思是，将资源封装到一个类中。类的构造函数里面加上申请资源的代码，在类的析构函数里面加上释放资源的代码。在多线程的线程函数中，创建这样一个临时局部对象，此时可能会申请到资源。那么，在线程函数结束时，系统会自动调用对象的析构函数。此时资源就会被释放。

原理是，局部临时变量或者对象，会在函数返回后自动销毁。

5、管理mutex的对象的两个类std::lock_guard和std::unique_lock

这两个类利用的是RAII原理，管理mutex对象。

std::lock_guard和std::unique_lock的区别

区域锁lock_guard使用起来比较简单，除了构造函数外没有其他member function，在整个区域都有效。
区域锁unique_guard除了lock_guard的功能外，提供了更多的member_function，相对来说更灵活一些。
unique_guard的最有用的一组函数为： lock 、try_lock 、try_lock_for、 try_lock_until、unlock
通过上面的函数，可以通过lock/unlock可以比较灵活的控制锁的范围，减小锁的粒度。
通过try_lock_for/try_lock_until则可以控制加锁的等待时间，此时这种锁为乐观锁。

四 condition_variable

当 std::condition_variable 对象的某个 wait 函数被调用的时候，它使用 std::unique_lock(通过 std::mutex) 来锁住当前线程。当前线程会一直被阻塞，直到另外一个线程在相同的 std::condition_variable 对象上调用了 notification 函数来唤醒当前线程。
std::condition_variable 对象通常使用 std::unique_lockstd::< mutex> 来等待，如果需要使用另外的 lockable 类型，可以使用std::condition_variable_any 类，

五