C++11最引人注目的特征之一便是其引入了对线程的支持
1. 基础知识回顾
1.1 线程 & 进程
- 进程是资源分配和调度的一个独立单位。而线程是进程的一个实体，是CPU调度和分派的基本单位。
- 一个进程至少拥有一个线程。
- 在同一个进程中的多个线程的内存资源是共享的，也就是说各线程都可以改变进程中的变量。因此在执行多线程运算的时候要注意执行顺序。
1.2 并发 & 并行
- 并行（parallellism）指的是多个任务在同一时刻同时在执行。
- 并发（concurrency）是指在一个时间段内，多个任务交替进行。虽然看起来像在同时执行，但其实是交替的。
2. C++11 线程
C++11提供了一套精练的线程库，小巧且易用。运行一个线程，可以直接创建一个std::thread的实例，线程在实例成功构造时启动。下面给出一个简单的示例：
#include <thread>
#include <iostream>
using namespace std;
void foo() {
cout << "Hello C++11" << endl;
}
int main() {
thread thread1(foo); // 启动线程foo
thread1.join(); // 等待线程执行完成
return 0;
}
/*
输出：
Hello C++11
*/
2.1 线程参数传入
查看源代码我们不难发现以下代码：
explicit thread(_Fp&& __f, _Args&&... __args);
其中：fn，可以指向函数，指向成员，或是移动构造函数；args，是传递给fn的参数，这些参数可以移动赋值构造。如果fn是一个成员指针，那么第一个args参数就必须是一个对象，或是引用，或是指向该对象的指针。下面的样例代码是对最开始的代码的改进：
void foo(string str)
{
cout << "Hello C++11 " + str << endl;
}
int main()
{
thread thread1(foo,"thread"); // 启动线程foo
thread1.join(); // 等待线程执行完成
return 0;
}
//输出：Hello C++11 thread
同理，将类成员函数作为线程入口也是可以的——只需要将this作为第一个参数进行传递，即可：
#include <thread>
#include <iostream>
class Greet
{
const char *owner = "Greet";
public:
void SayHello(const char *name) {
std::cout << "Hello " << name << " from " << this->owner << std::endl;
}
};
int main() {
Greet greet;
std::thread thread(&Greet::SayHello, &greet, "C++11"); ////注意在调用非静态类成员函数时，需要加上实例变量。
thread.join();
return 0;
}
//输出：Hello C++11 from Greet
此外，需要额外注意的是：当调用函数的参数为引用参数时，线程调用需要加上ref关键字表示引用。并且线程函数会改变引用的变量值。
void Add1(int n)
{
n++;
cout << "n=" << n << endl;
}
void Add2(int &n)
{
n++;
cout << "n=" << n << endl;
}
int main()
{
int n = 0;
thread t1(Add1, n);
t1.join();
cout << "n=" << n << endl;
thread t2(Add2, ref(n));
t2.join();
cout << "n=" << n << endl;
return 0;
}
/*
输出：
n=1
n=0
n=1
n=1
*/
2.2 线程管理
等待线程完成
一般来说,我们在主线程中开辟出一些子线程来完成我们的任务。正常情况下，需要在主线程的最后调用join()，用于阻塞主线程，避免主线程先于其他子线程执行完毕退出，然后导致整个进程的异常。其中，join的作用就是等待线程执行完成。也就是说，join函数返回时，说明子线程执行完成。
join：阻塞当前线程，直至 *this 所标识的线程完成其执行。*this 所标识的线程的完成同步于从 join() 的成功返回。该方法简单暴力，主线程等待子进程期间什么都不能做。thread::join()会清理子线程相关的内存空间，此后thread object将不再和这个子线程相关了，即thread object不再joinable了，所以join对于一个子线程来说只可以被调用一次，为了实现更精细的线程等待机制，可以使用条件变量等机制。我们不妨参考以下示例：
void pause_thread(int n)
{
cout<<"No."<<n<<" starting..."<<endl;
this_thread::sleep_for(chrono::seconds(n));
cout << "\t pause of " << n << "s ended" << endl;
cout<<"No."<<n<<" finished"<<endl;
}
int main()
{
cout << "Spawning 3 threads..." << endl;
thread t1(pause_thread, 2);
thread t2(pause_thread, 4);
thread t3(pause_thread, 6);
//cout << "Done spawning threads. Waiting them join..." << endl;
t1.join();
t2.join();
t3.join();
cout << "All threads done!" << endl;
return 0;
}
/*
输出：
Spawning 3 threads...
No.2 starting...
No.4 starting...
No.6 starting...
pause of 2s ended
No.2 finished
pause of 4s ended
No.4 finished
pause of 6s ended
No.6 finished
All threads done!
*/
线程暂停
从外部让线程暂停，会引发很多并发问题。这大概也是std::thread并没有直接提供pause函数的原因。但有时线程在运行时，确实需要“停顿”一段时间怎么办呢？可以使用std::this_thread::sleep_for或std::this_thread::sleep_until。如下：
void pause_thread(int n)
{
this_thread::sleep_for(chrono::seconds(n));
cout << "pause of " << n << "s ended" << endl;
this_thread::sleep_until(chrono::system_clock::now() + chrono::seconds(n));
cout << "continue" << endl;
}
int main()
{
cout << "Spawning 3 threads..." << endl;
thread th1(pause_thread, 2);
thread th2(pause_thread, 4);
thread th3(pause_thread, 6);
cout << "Done spawning threads. Now waiting for them to join:" << endl;
th1.join();
th2.join();
th3.join();
cout << "All threads joined!" << endl;
return 0;
}
/*
输出：
Spawning 3 threads...
Done spawning threads. Now waiting for them to join:
pause of 2s ended
continue
pause of 4s ended
pause of 6s ended
continue
continue
All threads joined!
*/
线程拷贝
std::thread a(foo);
std::thread b;
b = a;
当执行以上代码时，foo线程最终是由b来管理。std::thread被设计为只能由一个实例来维护线程状态，以及对线程进行操作。因此当发生赋值操作时，会发生线程所有权转移。赋完值后，原来由a管理的线程改为由b管理，b不再指向任何线程(相当于执行了detach操作)。如果b原本指向了一个线程，那么这个线程会被终止掉。具体示例如下：
void Add2(int &n)
{
n++;
cout << "n=" << n << endl;
}
int main()
{
int n=0;
thread t1(Add2,ref(n));
thread t2(move(t1)); ////此时t2正在运行Add2()，t1不再是一个线程了。
t2.join();
return 0;
}
detach
在使用join等待线程完成时，我们可能会想：创建多个线程完成一些任务,不过需要主线程最后等待所有的子线程完毕才能退出,这样不好。所以,detach()应运而生，希望主线程可以正常的退出, 子线程被挪到后台运行。
detach：分离线程的对象。即：将本线程从调用线程中分离出来，允许本线程独立执行。(但是当主进程结束的时候，即便是detach出去的子线程不管有没有完成都会被强制杀死)。参考以下示例：
void pause_thread(int n)
{
this_thread::sleep_for(chrono::seconds(n));
cout << "pause of " << n << "s ended" << endl;
}
int main()
{
cout << "Spawning 3 threads..." << endl;
thread(pause_thread, 2).detach();
thread(pause_thread, 4).detach();
thread(pause_thread, 6).detach();
cout << "Done spawning threads." << endl;
cout << "(the main thread will now pause for 5 seconds)\n";
// give the detached threads time to finish (but not guaranteed!):
pause_thread(5);
return 0;
}
/*
输出：
Spawning 3 threads...
Done spawning threads.
(the main thread will now pause for 5 seconds)
pause of 2s ended
pause of 4s ended
pause of 5s ended
*/
可见：当主进程结束的时候，即便是detach出去的子线程不管有没有完成都会被强制杀死（thread(pause_thread, 6).detach();）在主进程结束时并未完成就被强制结束。
P.s：detach以后就失去了对线程的所有权，不能再调用join了，因为线程已经分离出去了，不再归该实例管了。当任一结束执行，其资源被释放。
joinable
joinable：判断线程是否还有对线程的所有权，返回true则有，否则为无。也就是说，joiable可以用来判断当前线程是否能够调用join()或者detach()，可以返回true；不可以返回false。即：调用过join就不能在后面调用detach；调用过detach就不能在后面调用join。其常用方式如下：
//...exa
thread t1(fun);
if (t1.joinable() )
{
//ok to call join/detach
}
else
{
//ban
}
获取线程ID
通过get_id()可以获得线程id信息：
void thread_function(string &s)
{
cout << "thread function ";
cout << "message is = " << s << endl;
}
int main(){
void thread_function(string &s)
{
cout << "thread function ";
cout << "message is = " << s << endl;
s = "CBA";
}
return 0;
}
//输出：
main thread message = ABC
Main thread id is: 0x10994fdc0
Child thread id is: 0x70000fa4f000
thread function message is = ABC