[多线程]C++11多线程用法整理

C++11中加入了头文件，此头文件主要声明了std::thread线程类。C++11的标准类std::thread对线程进行了封装，定义了C++11标准中的一些表示线程的类、用于互斥访问的类与方法等。应用C++11中的std::thread便于多线程程序的移值。

关联头文件

：该头文件主要声明了 std::thread 类，另外 std::this_thread 命名空间也在该头文件中。

C++11新标准中引入了四个头文件来支持多线程编程，他们分别是,,和。

1. ：该头文主要声明了两个类, std::atomic 和std::atomic_flag，另外还声明了一套 C 风格的原子类型和与 C 兼容的原子操作的函数。
2. ：该头文件主要声明了与互斥量(mutex)相关的类，包括 std::mutex系列类，std::lock_guard, std::unique_lock, 以及其他的类型和函数。
3. ：该头文件主要声明了与条件变量相关的类，包括std::condition_variable和std::condition_variable_any。
4. ：该头文件主要声明了 std::promise, std::package_task 两个 Provider类，以及 std::future 和 std::shared_future 两个 Future类，另外还有一些与之相关的类型和函数，std::async() 函数就声明在此头文件中。

类成员

参考

构造函数

• 默认构造函数，创建一个空的 thread 执行对象。
• 初始化构造函数，创建一个 thread对象，该 thread对象可被 joinable，新产生的线程会调用 fn 函数，该函数的参数由 args 给出。接受任意的可调用对象类型（带参数或者不带参数），包括lambda表达式（带变量捕获或者不带），函数，函数对象，以及函数指针，类成员函数。
• 拷贝构造函数(被禁用)，意味着 thread 不可被拷贝构造。
• move 构造函数，move 构造函数，调用成功之后 x 不代表任何 thread 执行对象。

观察器

• get_id：获取线程ID，返回一个类型为std::thread::id的对象。

• joinable：检查线程是否可被合并join。检查thread对象是否标识一个活动(active)的可行性线程。缺省构造的thread对象、已经完成join的thread对象、已经detach的thread对象都不是joinable。
• hardware_concurrency：静态成员函数，返回当前计算机最大的硬件并发线程数目。基本上可以视为处理器CPU的核心数目。
• native_handle：该函数返回与std::thread具体实现相关的线程句柄。native_handle_type是连接thread类和操作系统SDK API之间的桥梁，如在Linux g++(libstdc++)里，native_handle_type其实就是pthread里面的pthread_t类型，当thread类的功能不能满足我们的要求的时候(比如改变某个线程的优先级)，可以通过thread类实例的native_handle()返回值作为参数来调用相关的pthread函数达到目录。

操作

• join：调用该函数会阻塞当前线程。阻塞调用者(caller)所在的线程直至被join的std::thread对象标识的线程执行结束。让当前主线程等待所有的子线程执行完，才能退出。
• detach：将当前线程对象所代表的执行实例与该线程对象分离，使得线程的执行可以单独进行。一旦线程执行完毕，它所分配的资源将会被释放。线程 detach 脱离主线程的绑定，主线程挂了，子线程不报错，子线程执行完自动退出。
  线程 detach以后，子线程会成为孤儿线程，线程之间将无法通信。我们称分离的线程叫做守护线程（daemon threads）
• swap：交换二个 thread 对象

另外，std::thread::id表示线程ID，定义了在运行时操作系统内唯一能够标识该线程的标识符，同时其值还能指示所标识的线程的状态。

有时候我们需要在线程执行代码里面对当前调用者线程进行操作，针对这种情况，C++11里面专门定义了一个命名空间this_thread，此命名空间也声明在头文件中，其中包括

• get_id()函数用来获取当前调用者线程的ID；
• yield()函数可以用来将调用者线程跳出运行状态，重新交给操作系统进行调度，即当前线程放弃执行，操作系统调度另一线程继续执行；让cpu执行其他空闲的线程。
• sleep_until()函数是将线程休眠至某个指定的时刻(time point),该线程才被重新唤醒；
• sleep_for()函数是将线程休眠某个指定的时间片(time span)，该线程才被重新唤醒，不过由于线程调度等原因，实际休眠实际可能比sleep_duration所表示的时间片更长。

多线程数据竞争

多个线程同时对同一变量进行操作的时候，如果不对变量做一些保护处理，有可能导致处理结果异常。

#include 
#include 
using namespace std;

int cnt = 20;
void fun1()
{
    while (cnt > 0)
    {
        if(cnt > 0)
        {
            --cnt;
            cout<< cnt << " ";
        }
    }
}

int main()
{
    thread t1(fun1);
    thread t2(fun1);

    t1.join();
    t2.join();
    std::cout << "\nhere is the main()" << std::endl;

    return 0;
}
//输出，没有按顺序输出
//1918  16 17 15 14 13 12 11 9 10 8 7 6 5 4 3 2 1 0
//here is the main()

输出的数字不是顺序的。这是由于第一个线程对变量操作的过程中，第二个线程也对同一个变量进行各操作，导致第一个线程处理完后的输出有可能是线程二操作的结果。针对这种数据竞争的情况，可以使用线程互斥对象mutex保持数据同步。

join/detach

#include 
#include 
#include 

using namespace std;

void thread01()
{
    for (int i = 0; i < 5; i++)
    {
        cout << "Thread 01 is working !" << endl;
        std::this_thread::sleep_for(chrono::milliseconds(100));
    }
}
void thread02()
{
    for (int i = 0; i < 5; i++)
    {
        cout << "Thread 02 is working !" << endl;
        std::this_thread::sleep_for(chrono::milliseconds(100));
    }
}

int main()
{
    thread task01(thread01);
    thread task02(thread02);
//    task01.join();
//    task02.join();

    task01.detach();
    task02.detach();

    for (int i = 0; i < 5; i++)
    {
        cout << "Main thread is working !" << endl;
        std::this_thread::sleep_for(chrono::milliseconds(100));
    }
    return 0;
}
/*
------join的输出------
Thread 01 is working !Thread 02 is working !

Thread 01 is working !
Thread 02 is working !
Thread 01 is working !
Thread 02 is working !
Thread 01 is working !
Thread 02 is working !
Thread 01 is working !
Thread 02 is working !
Main thread is working !
Main thread is working !
Main thread is working !
Main thread is working !
Main thread is working !

------detach的输出------
Thread 01 is working !
Main thread is working !
Thread 02 is working !
Thread 01 is working !
Thread 02 is working !
Main thread is working !
Thread 01 is working !
Thread 02 is working !
Main thread is working !
Thread 02 is working !
Thread 01 is working !
Main thread is working !
Thread 02 is working !
Thread 01 is working !
Main thread is working !

 */

总结：

• 两个子线程并行执行，join函数会阻塞主流程，所以子线程都执行完成之后才继续执行主线程。可以使用detach将子线程从主流程中分离，独立运行，不会阻塞主线程用；detach的主线程和两个子线程并行执行。
• join 是让当前主线程等待所有的子线程执行完，才能退出。
• 线程 detach 脱离主线程的绑定，主线程挂了，子线程不报错，子线程执行完自动退出。线程 detach以后，子线程会成为孤儿线程，线程之间将无法通信。

mutex和std::lock_guard的使用

头文件是#include ，mutex是用来保证线程同步的，防止不同的线程同时操作同一个共享数据。

但使用lock_guard则相对安全，它是基于作用域的，能够自解锁，当该对象创建时，它会像m.lock()一样获得互斥锁，当生命周期结束时，它会自动析构(unlock)，不会因为某个线程异常退出而影响其他线程。

#include 
#include 
#include 
using namespace std;

int cnt = 20;
mutex m;
void fun1()
{
    while (cnt > 0)
    {
        std::lock_guard lockGuard(m);
//        m.lock();
        if (cnt > 0)
        {
            --cnt;
            cout<< cnt << " ";
        }
//        m.unlock();
    }
}

int main()
{
    thread t1(fun1);
    thread t2(fun1);

    t1.join();
    t2.join();
    std::cout << "\nhere is the main()" << std::endl;

    return 0;
}
//输出结果，cnt是依次递减的，没有因为多线程而打乱次序
//19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
//here is the main()

Mutex使用如下，首先在线程之外声明mutex变量，在线程进入临界区之前调用该变量的lock()函数，出临界区之前调用unlock()。虽然该程序得到了正确的结果，但程序本身并不正确。因为cout输出时理论上会抛出异常，一旦其抛出异常mutex变量的unlock()便不能执行。这意味着该锁没有被释放，整个程序无法进入该临界区，往往程序会挂死。该问题属于异常安全问题，在抛出异常时需要注意一些收尾操作。这也是RAII的设计目标之一，标准库提供了一种RAII锁形式，即lock_guard。

Lock_guard

同样首先在线程之外声明mutex变量，在线程进入临界区之前声明lock_guard变量，将mutex变量作为变量传入，在构造函数中会调用该变量的lock()，在析构函数中调用unlock()，如此无论是正常运行结束还是临界区中出现异常都会正常执行锁操作。lock_guard优势是实现简单、使用方便，适用于大多数场景，但存在的问题是使用场景过于简单，无法处理一些精细操作。此时便需要使用unique_lock。

unique_lock

unique_lock基本用法和lock_guard一致，在构造函数和析构函数中进行锁操作，不同的地方在于它提供了非常多构造函数。

• 第一种unique_lock()是默认构造函数，不持有mutex，因此也不做锁操作。
• unique_lock(unique_lock&&)提供移动mutex的所有权。
• unique_lock(mutex_type&)持有mutex并上锁，也就是上述实例中采用的构造函数。
• 并且可以加上参数try_to_lock_t，即后一种构造函数，这意味着可以试图上锁，如果不成功仍然持有该mutex，但没有上锁。
• Defer_lock_t是指持有mutex但不执行上锁操作，
• adopt_lock_t是指已知该mutex上锁，直接持有该mutex。
• 另外如果该mutex是timed_mutex，可以持有该mutex并尝试上锁一段时间，或者尝试上锁到某个时间点。