博客

在windows上面启线程时，用的是windows的API，前辈说可以去学一下C++11 提供的线程库，比较方便灵活。下面就介绍一下thread的用法。

std::thread::thread

构造新的

thread

对象。

1) 构造不表示线程的新

thread

对象。

2) 移动构造函数。构造表示曾为

other

所表示的执行线程的

thread

对象。此调用后

other

不再表示执行线程。

3) 构造新的

std::thread

对象并将它与执行线程关联。新的执行线程开始执行

4) 复制构造函数被删除；

thread

不可复制。没有两个

std::thread

对象可表示同一执行线程。

std::thread::~thread

在下列操作后 thread 对象无关联的线程（从而可安全销毁）

• 被默认构造
• 被移动
• 已调用
  
  join()
  
• 已调用
  
  detach()
  

std::thread::operator=

这个例子是借鉴

cppreference.com

这个网站上面的，我详细的分析一下这个例子。

#include <iostream>
#include <utility>
#include <thread>
#include <chrono>

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));
	}
}

void f2(int& n){
	for (int i = 0; i < 2; ++i) {
		std::cout << "Thread 2 executing\n";
		++n;
		std::this_thread::sleep_for(std::chrono::milliseconds(10));
	}
}

class foo{
public:
	void bar(){
		for (int i = 0; i < 2; ++i) {
			std::cout << "Thread 3 executing\n";
			++n;
			std::this_thread::sleep_for(std::chrono::milliseconds(10));
		}
	}
	int n = 0;
};

class baz{
public:
	void operator()(){
		int n = 0;
		for (int i = 0; i < 2; ++i) {
			std::cout << "Thread 4 executing\n";
			++n;
			std::this_thread::sleep_for(std::chrono::milliseconds(10));
		}
	}
};

int main(){
	int n = 0;
	foo f;
	baz b;
	std::thread t1; // t1 不是线程
	std::thread t2(f1, n + 1); // 按值传递
	std::thread t3(f2, std::ref(n)); // 按引用传递
	std::thread t4(std::move(t3)); // t4 现在运行 f2() 。 t3 不再是线程
	std::thread t5(&foo::bar, &f); // t5 在对象 f 上运行 foo::bar()
	std::thread t6(b); // t6 在对象 b 上运行 baz::operator()

	t1 = std::thread(f1, n + 1); //t1等号运算符重载
	std::thread t7(std::thread(f2, std::ref(n))); //t7拷贝构造
	t2.join();
	t4.join();
	t5.join();
	t6.join();
	t1.join();
	t7.join();
	std::cout << "Final value of n is " << n << '\n';
	std::cout << "Final value of foo::n is " << f.n << '\n';
}

可以看到只是调用默认构造函数（构造函数（1））构造线程，线程是不会被构造的，如图，线程t1没有被构造。

线程t2，t3调用构造函数（3） ，参数Function&& f, Args&&… args，f实质上是一个函数指针，保存线程所要执行的函数的地址，args是函数的参数，线程运行f(args)，线程t5因为调用的是类的成员方法，this指针作为非静态成员函数的隐含形参，因此我们将this指针即就是对象的地址传进去。

线程t4调用拷贝构造函数（构造函数（2）），thread的拷贝构造函数只有右值拷贝构造，左值的拷贝构造被删除了，右值引用是指函数的参数可以是临时变量，如线程t7，由一个临时变量std::thread(f2, std::ref(n))构造t7。而t4使用的std::move(t3)，其中

template< class T >

typename

std::remove_reference

<T>::type&& move( T&& t ) noexcept;

std::move返回的是一个右值引用的变量，而函数的作用是将t到另一对象有效率的资源传递，传递过后，资源t会被销毁。在这个表达式中的作用就是将线程t3的资源传递给t4，并销毁t3。

线程t6是调用构造函数（3），而这个类里面有operator()()，括号的运算符重载，只要这个对象被使用，那么就会调用括号运算符重载。

线程t1调用等号运算符重载。

最后运行的结果：

线程2-5运行了两遍，所以上面的函数分别打印了2遍，另外线程1,7又将函数f1和f2打印了2遍。

std::thread::joinable

检查线程是否可合并，即潜在地运行于平行环境中

#include <iostream>
#include <thread>
#include <chrono>
 
void foo(){
    std::this_thread::sleep_for(std::chrono::seconds(1));
}
 
int main(){
    std::thread t;
    std::cout << "before starting, joinable: " << std::boolalpha << t.joinable()
              << '\n';
 
    t = std::thread(foo);
    std::cout << "after starting, joinable: " << t.joinable() 
              << '\n';
 
    t.join();
    std::cout << "after joining, joinable: " << t.joinable() 
              << '\n';
}

我们可以看到，在线程为活跃之前，joinable的值为false，在线程活跃之后，joinable的值为true。在线程被join，detach之后，置joinable的值为false。joinable被置为false的情况有

• 被默认构造
• 被移动
• 已调用
  
  join()
  
• 已调用
  
  detach()
  

这些情况和线程被析构的情况都是一样的，因为thread的析构函数是这样实现的

joinable为true的话，会调用terminate()，terminate()会调用abort()来终止程序，程序会报错，因此只有joinable变成false，才能执行析构函数，因此两者运行的必要条件是一样的。

std::thread::join

等待线程完成其执行

std::thread::detach

容许线程从线程句柄独立开来执行。

join和detach执行的必要条件都是joinable是true。

join和detach的区别，join会阻塞当前的线程，直到运行的线程结束，比如在main函数里面调用线程thread，那么main函数里面调用thread后，会先去执行thread中的代码逻辑，直到其结束，再去执行main函数里面的代码逻辑。调用join后，所有分配的资源都会被释放。在调用了join之后，*this就不会拥有任何线程了。

detach从线程对象中分离出执行线程，允许线程独立的执行。一旦线程退出，所有分配的资源都会被释放。在调用了detach之后，*this就不会拥有任何线程了。

以上图片借鉴

https://www.cnblogs.com/ittinybird/p/4820142.html

，这篇文章也写得很好，大家可以看一下。

可能光说还是有点抽象，上代码：

#include <iostream>
#include <thread>
#include <chrono>

void foo(){
	for (int i = 0; i < 5; ++i){
		std::cout << "void foo()" << std::endl;
	}
}

void bar(){
	for (int i = 0; i < 5; ++i) {
		std::cout << "void bar()" << std::endl;
	}
}

int main(){
	std::thread helper1(foo);
	std::thread helper2(bar);

	helper1.join();
	helper2.join();
	for (int i = 0; i < 5; ++i){
		std::cout << "done!\n";
	}
}

#include <iostream>
#include <thread>
#include <chrono>

void foo(){
	for (int i = 0; i < 5; ++i){
		std::cout << "void foo()" << std::endl;
	}
}

void bar(){
	for (int i = 0; i < 5; ++i) {
		std::cout << "void bar()" << std::endl;
	}
}

int main(){
	std::thread helper1(foo);
	std::thread helper2(bar);

	helper1.detach();
	helper2.detach();
	for (int i = 0; i < 5; ++i){
		std::cout << "done!\n";
	}
	system( "pause");
}

可以看出来，detach不会阻塞主线程，主线程和子线程是同时运行的。而join是会阻塞主线程，等待子线程运行完后，在运行主线程。

其他一些函数，不太常用，但要知道。我贴出来。

std::thread::get_id

返回标识与 *this 关联的线程的

std::thread::id

类型值。

std::thread::native_handle

返回实现定义的底层线程句柄。

std::thread::hardware_concurrency

返回实现所支持的并发线程数。

std::thread::swap

互换二个 thread 对象的底层句柄。

std::swap(std::thread)

为

std::thread

特化

std::swap

算法。交换

lhs

与

rhs

的状态。等效地调用 lhs.swap(rhs) 。

#include <iostream>
#include <thread>
#include <chrono>

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();
}

文章借鉴：

cppreference.com