头文件

#include <thread>             // std::thread
#include <mutex>              // std::mutex, std::unique_lock
#include <condition_variable> // std::condition_variable

thread

constructor

thread() noexcept;
thread( thread&& other ) noexcept;
template< class Function, class... Args >
explicit thread( Function&& f, Args&&... args );
thread( const thread& ) = delete;

thread 不可复制，没有两个 std::thread 对象可表示同一执行线程。

destructor

~thread();

Destroys the thread object.

If *this has an associated thread (joinable() == true), std::terminate() is called.

int main()
{
    {
        thread th1(t1);  // th1离开作用域析构后,线程被终止;
        cout << std::boolalpha << th1.joinable() << endl;  // true
    }
    
    while (1);
    return 0;
}

operator=

thread& operator=( thread&& other ) noexcept;

thread 不可复制，没有两个 std::thread 对象可表示同一执行线程。

joinable

thread::joinable() 用来判断线程对象是否持有一个活动的执行线程(执行实例)。以下情况的线程对象不持有实际线程：

缺省构造的thread对象

std::thread t1; // t1不是线程
t1.joinable();  // false
/////////////////////////////////////////////////
void f1(int n){
    for (int i = 0; i < 2; ++i) {
        std::cout << "Thread 1 executing\n";
        ++n;
        std::this_thread::sleep_for(std::chrono::milliseconds(10));
    }
}

std::thread t2(f1, n + 1); 
t2.joinable();   // true

调用了thread::join()的对象

void t1()  //普通的函数，用来执行线程
{
    for (int i = 0; i < 5; ++i)
    {
        cout << "t1111" << endl;
        std::this_thread::sleep_for(std::chrono::milliseconds(1000));
    }
}

int main()
{
    thread th1(t1); 
    cout << std::boolalpha << th1.joinable() << endl;  // true
    th1.join(); 
    cout << std::boolalpha << th1.joinable() << endl;;  // false
    cout << "here is main\n\n";
    while (1);
    return 0;
}

调用了thread::detach()的对象

int main()
{
    thread th1(t1); 
    cout << std::boolalpha << th1.joinable() << endl;  // true
    th1.detach(); 
    cout << std::boolalpha << th1.joinable() << endl;;  // false
    cout << "here is main\n\n";
    while (1);
    return 0;
}

join

调用该函数会阻塞当前线程（主调线程）

阻塞调用者(caller)所在的线程（主调线程）直至被join的std::thread对象标识的线程（被调线程执行结束。

detach

detach是用来和线程对象分离的，这样线程可以独立地执行，一旦线程执行完毕，操作系统分配的资源将会被释放。不过这样由于没有thread对象指向该线程而失去了对它的控制。

当对象析构时线程会继续在后台执行，但是当主程序退出时并不能保证线程能执行完。

如果没有良好的控制机制或者这种后台线程比较重要，最好不用detach而应该使用join。

swap

交换两个线程对象所代表的底层句柄

mutex

std::mutex  mux;
mux.lock();
mux.unlock();

lock

std::lock_guard , 与Mutex RAII相关，方便线程对互斥量上锁。

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

std::mutex  m;
std::lock_guard<mutex>  lock1(m);
std::unique_lock<mutex> lock2(m);

condition_variable

#include <iostream>
#include <thread>
#include <stdlib.h> 
#include <chrono>
#include <mutex>
#include <condition_variable>
#include <queue>

using namespace std;

std::mutex mux;
std::condition_variable cond;
std::queue<int> q;

void producer()
{
    for (int i = 0; i < 10; ++i)
    {
        std::unique_lock<mutex> lock(mux);
        std::this_thread::sleep_for(std::chrono::milliseconds(1000));
        q.push(i);
        cond.notify_one();
    }
}

void consumer()
{
    while (1)
    {
        std::unique_lock<mutex> lock(mux);
        while (q.empty())
        {
            cond.wait(lock);
        }
        cout << "consumer " << q.front() << endl;
        q.pop();
    }
}

int main()
{
    std::thread t1(producer);
    std::thread t2(consumer);
    t1.join();
    cout << "producer finished " << endl;
    t2.join();
    return 0;
}

C++ Thread