C++中线程库的基本操作

进程：运行中的程序。

线程：进程中的进程。是最小资源管理单元。

单线程：煮九个馒头，一个一个煮，要用九分钟。

多线程：煮九个馒头，一起放到锅里煮，用一分钟。

C++11提供了一个强大的线程库，即std::thread.它可以在C++程序中创建和管理线程。

要创建线程，我们需要一个可调用的函数或函数对象作为现成的入口点。我们可以使用函数指针、函数对象或者lambda表达式来实现。

#include<iostream>
#include<thread>

void base()
{
	std::cout << "hello" << std::endl;
	return;
}

int main()
{
	std::thread t1(base);
	return 0;
}

运行结果：

为什么？

因为主线程并不会等待子线程运行完再结束。也就是说，你可能只能见到"h"，也可能是"he"，也可能是"hel"，"hell"，"hello".

解决方法：

#include<iostream>
#include<thread>

void base()
{
	std::cout << "hello" << std::endl;
	return;
}

int main()
{
	std::thread t1(base);
	t1.join();
	return 0;
}

使用join，主程序会等待子线程直至其执行完毕。它会检查子线程是否运行完。

如果使用system("pause")呢？system("pause")的功能是：不按下任意键，就不会走到return 0那一步。

我们可以使用多种方式向线程传递参数，例如使用函数参数、全局变量、引用等。

#include<iostream>
#include<thread>
#include<string>

void print(const std::string& message)
{
	std::cout << message << std::endl;
}

void increment(int& x)
{
	x++;
}

int main()
{
	std::string msg = "hello";
	std::thread t1(print, msg);
	t1.join();
	int x = 0;
	std::thread t2(increment, std::ref(x));
	t2.join();
	std::cout << x << std::endl;
	return 0;
}

注意，当我们使用引用传递参数时，要使用std::ref来包装引用。

再来看一个例子：

#include<iostream>
#include<thread>
#include<string>

void print(const std::string& message)
{
	std::cout << message << std::endl;
}

int main()
{
	std::string msg1 = "t1";
	std::string msg2 = "t2";
	std::thread t1(print, msg1);
	std::thread t2(print, msg2);
	t1.join();
	t2.join();
	
	return 0;
}

我们会发现运行的结果是随机的：

结果之所以是随机的，是因为线程的调度顺序是由操作系统决定的，具有不确定性。两个线程是并发执行的，可能同时竞争输出资源std::cout.如果对顺序有要求，可以考虑使用互斥锁等，我们在接下来的文章再讲。

有时候我们不需要等待线程完成，而是希望它在后台运行，可以使用.detach()方法来分离线程。

#include<iostream>
#include<thread>
#include<string>

void print(const std::string& message)
{
	std::cout << message << std::endl;
}

int main()
{
	std::string msg1 = "t1";
	std::thread t1(print, msg1);
	t1.detach();
	std::cout << "over" << std::endl;
	return 0;
}

运行结果只有"over"

分离了线程就不能使用.join()等待它完成。并且我们需要保证线程不会在主线程结束前退出，否则可能会导致未定义行为。

.joinable():

有一些情况下，线程对象不能被.join()或.detach()，就要使用.joinable()进行检查。不能使用.join()或.detach()主要有以下几种情况：

1.默认构造的std::thread，即没有绑定任何可执行线程。

std::thread t;//默认构造，不关联任何线程

2.已经被join()或detach()的线程。如果再次join()或detach()，就会抛出std::system_error

std::thread t([]{ std::cout << "Hello"; });
t.join();      // 正确，等待线程结束
// t.join();    // 错误！线程已经 join 过
// t.detach();  // 错误！线程已经 join 过

3.被移动过的std::thread（所有权已转移）。原来的对象不再管理线程。

std::thread t1([]{ std::cout << "Thread 1"; });
std::thread t2 = std::move(t1);  // t1 的所有权转移给 t2
// t1.join();    // 错误！t1 不再管理线程
// t1.detach();  // 错误！t1 不再管理线程
t2.join();      // 正确

关于move函数，在后面的文章会详细讲解。

4.线程对象已经被销毁

所以在调用.join()或.detach()之前，始终检查joinable()：

std::thread t(...);
if (t.joinable()) 
{
    t.join();  // 或 t.detach();
}