上一篇：《深入应用C++11》笔记-std::function和bind
原来开发多线程在windows和linux各有各的接口，C++ 11有了标准的线程库：std::thread。
构造函数和赋值操作
std::thread定义了四个构造函数：
- 默认构造函数，创建一个空的 std::thread 执行对象。
- 初始化构造函数，创建一个 std::thread 对象，该std::thread 对象可被 joinable，新产生的线程会调用 fn 函数，该函数的参数由 args 给出。
- 拷贝构造函数(被禁用)，意味着 std::thread 对象不可拷贝构造，因为线程无法拷贝。
- 移动构造函数，详见(https://blog.csdn.net/wizardtoh/article/details/80718605中的移动构造函数)，调用成功之后 x 不代表任何 std::thread 执行对象。
void f1(int n)
{
for (int i = 0; i < 5; ++i) {
std::cout << "Thread " << n << " executing" << i << "\n";
// 作用相当于sleep，后续的文章会具体介绍
std::this_thread::sleep_for(std::chrono::milliseconds(10));
}
}
void f2(int& n)
{
for (int i = 0; i < 5; ++i) {
std::cout << "Thread 2 executing" << i << "\n";
++n;
std::this_thread::sleep_for(std::chrono::milliseconds(10));
}
}
int main()
{
int n = 0;
std::thread t1; // 没有执行线程
std::thread t2(f1, n + 1); // 执行线程，运行f1
std::thread t3(f2, std::ref(n)); // 执行线程，运行f2
std::thread t4(std::move(t3)); // f2在t4中运行，t3不再是线程
// 下面会介绍join的内容
t2.join();
t4.join();
std::cout << "Final value of n is " << n << '\n';
return 0;
}同时定义了两个赋值操作：
- Move 赋值操作，如果当前对象不可 joinable，需要传递一个右值引用(rhs)给 move 赋值操作；如果当前对象可被
joinable，则会调用 terminate() 报错。 - 拷贝赋值操作，被禁用，意味着std::thread 对象不可拷贝赋值，因为线程无法拷贝。
int main(int argc, const char *argv[])
{
std::thread threads[5];
std::cout << "Spawning 5 threads...\n";
for (int i = 0; i < 5; i++) {
threads[i] = std::thread(thread_task, i + 1); // 移动赋值，std::thread(thread_task, i + 1)作为右值
}
std::cout << "Done spawning threads! Now wait for them to join\n";
for (auto& t : threads) {
t.join();
}
std::cout << "All threads joined.\n";
return 0;
}成员函数
std::thread还提供了一些成员函数来辅助线程。
get_id：获取线程 ID，返回一个类型为 std::thread::id 的对象。
void foo(int n)
{
std::this_thread::sleep_for(std::chrono::seconds(n));
// 在线程中通过std::this_thread::get_id()获取线程ID
std::cout << "id:" << std::this_thread::get_id() << "\n";
}
int main()
{
std::thread t1(foo, 1);
std::thread::id t1_id = t1.get_id(); // 通过对象获取线程ID
std::thread t2(foo, 2);
std::thread::id t2_id = t2.get_id();
std::cout << "t1's id: " << t1_id << '\n';
std::cout << "t2's id: " << t2_id << '\n';
t1.join();
t2.join();
return 0;
}joinable：检查线程是否可被 join。检查当前的线程对象是否表示了一个活动的执行线程，由默认构造函数创建的线程是不能被 join 的。另外，如果某个线程已经执行完任务，但是没有被 join 的话，该线程依然会被认为是一个活动的执行线程，因此也是可以被 join 的。
int main()
{
std::thread t1;
t1.join(); // thread对象没有执行线程，join会造成程序错误
return 0;
}
void foo(int n)
{
std::this_thread::sleep_for(std::chrono::seconds(n));
std::cout << "id:" << std::this_thread::get_id() << "\n";
}
int main()
{
std::thread t1(foo, 1); // thread执行了线程，但是没有join，在程序结束时也会造成异常
return 0;
}使用joinable可以解决以上问题：
void foo(int n)
{
std::this_thread::sleep_for(std::chrono::seconds(n));
std::cout << "id:" << std::this_thread::get_id() << "\n";
}
int main()
{
std::thread t1(foo, 1);
if (t1.joinable()) // 执行线程的情况下才join
{
t1.join();
}
return 0;
}join：Join 线程，调用该函数会阻塞当前线程，直到由 *this 所标示的线程执行完毕 join 才返回。
detach: Detach 线程。 将当前线程对象所代表的执行实例与该线程对象分离，不会阻塞当前线程，使得线程的执行可以单独进行。一旦线程执行完毕，它所分配的资源将会被释放。调用 detach 函数之后：
- thread对象本身不再代表任何的线程执行实例，但是线程仍然在运行。
- joinable() == false，thread对象不再需要join。
- get_id() == std::thread::id()，也就是0x0
void foo(int n)
{
std::cout << "run" << "\n";
}
int main()
{
std::thread t1(foo, 1);
if (t1.joinable())
{
std::cout << "joinable" << std::endl;
}
std::cout << std::this_thread::get_id() << std::endl;
std::cout << t1.get_id() << std::endl;
t1.detach();
// detach之后，joinable返回false，get_id返回0x0
if (!t1.joinable())
{
std::cout << "can not joinable" << std::endl;
}
std::cout << t1.get_id() << std::endl;
return 0;
}在std::thread的析构函数中，如果线程没有被Joined（用t.join()，也没有被detached（用t.detach()，会引起程序异常。因此，你应该在执行流程到析构函数前总是要么join，要么detach一个线程。当一个程序终止时（比如main返回），剩下的在后台的detached线程执行不会再等待；相反它们的执行会被挂起并且它们的本地线程对象会被销毁。
swap: Swap 线程，交换两个线程对象所代表的底层句柄。通过下面的代码可以看到，thread对象的句柄会被交换。
void foo()
{
std::this_thread::sleep_for(std::chrono::seconds(1));
}
void bar()
{
std::this_thread::sleep_for(std::chrono::seconds(1));
}
int main()
{
std::thread t1(foo);
std::thread t2(bar);
std::cout << "thread 1 id: " << t1.get_id() << std::endl;
std::cout << "thread 2 id: " << t2.get_id() << std::endl;
std::swap(t1, t2);
std::cout << "after std::swap(t1, t2):" << std::endl;
std::cout << "thread 1 id: " << t1.get_id() << std::endl;
std::cout << "thread 2 id: " << t2.get_id() << std::endl;
t1.swap(t2);
std::cout << "after t1.swap(t2):" << std::endl;
std::cout << "thread 1 id: " << t1.get_id() << std::endl;
std::cout << "thread 2 id: " << t2.get_id() << std::endl;
t1.join();
t2.join();
return 0;
}native_handle: 返回本地句柄（由于 std::thread 的实现和操作系统相关，因此该函数返回与 std::thread 具体实现相关的线程句柄），通过这个句柄就能用对应操作系统的线程相关接口了。
std::this_thread 命名空间中相关辅助函数
在上面的介绍中已经有用到了std::this_thread命名空间的部分函数，std::this_thread是作用于当前运行的线程。
get_id: 获取当前的线程 ID。
yield: 当前线程放弃执行，操作系统调度另一线程继续执行，有点类似于sleep，不过yield会将自己抢到的时间片让给其他线程，而sleep只是等待。该方法的具体行为取决于实现，尤其是正在使用的操作系统调度器的机制以及系统的状态。比如，一个先进先出的实时调度器（Linux中的SCHED_FIFO）将会使当前线程暂停，并将其置于同优先级线程队列的末尾（如果同优先级线程队列里没有其他线程，yield就没有效果了。）
sleep_until: 线程休眠至某个指定的时刻(time point)，该线程才被重新唤醒。
sleep_for: 线程休眠某个指定的时间片(time span)，该线程才被重新唤醒，不过由于线程调度等原因，实际休眠时间可能比 sleep_duration 所表示的时间片更长。
#include <iostream>
#include <thread>
#include <chrono>
#include <ctime>
int main()
{
std::time_t tt = std::chrono::system_clock::to_time_t(std::chrono::system_clock::now());
struct std::tm * ptm = std::localtime(&tt);
std::cout << "Current time: " << tt << '\n';
std::this_thread::sleep_for(std::chrono::milliseconds(100));
tt = std::chrono::system_clock::to_time_t(std::chrono::system_clock::now());
ptm = std::localtime(&tt);
std::cout << "Current time: " << tt << '\n'; // 等待了100ms
std::cout << "Waiting for the next minute to begin...\n";
ptm->tm_min += 1;
ptm->tm_sec=0;
std::this_thread::sleep_until (std::chrono::system_clock::from_time_t (mktime(ptm)));
std::cout << ptm << " reached!\n";
tt = std::chrono::system_clock::to_time_t(std::chrono::system_clock::now());
std::cout << "Current time: " << tt << '\n'; // 等到了下一分钟
return 0;
}