C++ std::thread线程详解

1. thread是什么

多线程是一种功能，它允许并发执行程序的两个或多个部分，以最大限度地利用 CPU。这种程序的每个部分都称为线程。因此，线程是进程中的轻量级进程。多线程支持是在 C++11 中引入的。在 C++11 之前，我们必须使用 POSIX 线程或库。虽然这个库完成了这项工作，但缺乏任何标准语言提供的功能集导致了严重的可移植性问题。C++ 11 取消了所有这些，并给了我们 std::thread。线程类和相关函数在头文件<thread>中定义。

类thread表示单个执行线程。线程在构建关联的线程对象时立即开始执行。其定义用于观察和管理应用程序中的执行线程的对象。

2. 创建一个thread

std::thread 是 C++ 中表示单个线程的线程类。要启动线程，我们只需要创建一个新的线程对象，并将要调用的执行代码（即可调用对象）传递到对象的构造函数中。

//当程序到达此行时，将在后台启动任务以运行aFunction 
//t:线程对象
//aFunction: 任务或线程执行
std::thread t(aFunction);
1
2
3
4

创建对象后，将启动一个新线程，该线程将执行 aFunction 中指定的代码。可调用对象可以是以下五个项中的任何一个：

• 函数指针
• Lambda 表达式
• 函数对象
• 非静态成员函数
• 静态成员函数

定义可调用对象后，我们将其传递给构造函数。我们看以下例子：

/*****************1.使用函数指针启动线程********************/

//函数指针可以是可调用对象，传递给 std::thread 构造函数以初始化线程。
void foo(param)
{ 
   ... 
}
// The parameters to the function are put after the comma
std::thread thread_obj(foo, params);
/********************************************************/


/***************2.使用 Lambda 表达式启动线程****************/

//定义一个lambda表达式
auto f = [](params)
{
	...
};

//使用 lambda 表达式作为可调用对象来启动
std::thread thread_object(f, params);
/********************************************************/


/******************3.使用函数对象启动线程*******************/

// 定义一个函数对象
class fn_object_class {
	// 重载operator()
	void operator()(params)
	{ 
	   ...
	}
}

std::thread thread_object(fn_object_class(), params);
/********************************************************/


/***************4.使用非静态成员函数启动线程****************/

// 定义一个类
class Base {
public:
	// 非静态成员函数
	void foo(param) { ... }
}

//创建Base类对象b
Base b;

// 第一个参数是类非静态成员函数的引用
// 第二个参数类对象的引用
// 第三个参数是非静态成员函数的参数
std::thread thread_obj(&Base::foo, &b, params);
/********************************************************/


/***************5.使用静态成员函数启动线程****************/

// 定义一个类
class Base {
public:
	//静态成员数
	static void foo(param) { ... }
}

//创建Base类对象b
Base b;
// 其一个参数是类静态成员函数的引用
// 第二个参数是该函数的参数
std::thread thread_obj(&Base::foo, params);
/********************************************************/
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

注：我们总是将可调用对象的参数作为参数单独传递给线程构造函数。

3. 等待线程执行完毕

线程启动后，我们可能需要等待线程完成，然后才能采取一些操作。要等待线程，请使用 std::thread::join() 函数。此函数使当前线程等待，直到*this标识的线程完成执行。

int main()
{
	//开始一个线程t1
	std::thread t1(callable);

	//等待线程t1执行完成
	t1.join();

	//t1完成后再继续执行其他语句
	...
}
1
2
3
4
5
6
7
8
9
10
11

有时我们需要知道线程对象是否可连接，即它与活动任务相关联。我们可以通过函数对其进行 joinable() 评估：

if (t.joinable())
    t.join();
1
2

其主要是检查 std::thread 对象是否标识活跃的执行线程。具体而言，若 get_id() != std::thread::id() 则返回true。故默认构造的 thread 不可结合。

注：std::thread::get_id返回线程的 id，即返回标识与 *this 关联的线程的std::thread::id。

如果线程是 joinable ，并不意味着它已完成。它可能仍在运行。因此，如果我们调用 join() 一个 joinable 任务，它只有在它已经完成时才加入，否则，程序会等待它完成，然后加入。

4. 线程任务的移动和交换

没有两个 std::thread 对象会表示同一执行线程，因为 std::thread 是可移动构造且可移动赋值，但不是可复制构造或可复制赋值的。例如：

auto task(){/* 某些计算过程 */}
std::thread t1(task);
std::thread t2 = t1; //错误: 线程不可以复制
std::thread t3{t1}; // 错误: 线程不可以拷贝构造

//一次只有一个线程对象负责一个任务。但是，与线程对象关联的任务是可移动的：
std::thread t4 = std::move(t1); //正确: t4现在运行task，t1变成一个空对象
1
2
3
4
5
6
7

std::thread::swap成员函数可以交换两个 thread 对象，其实就是交换二个 thread 对象的底层柄。其函数原型如下：

void swap( std::thread& other ) noexcept; //C++11 起
1

除了可以使用成员函数外，也可以使用非成员数std::swap(std::thread) 来完成两个线程对象的交换。

void foo(){ ... }
void bar(){ ... }
std::thread t1(foo);
std::thread t2(bar);

//交换t1和t2
std::swap(t1, t2); //等效于t1.swap(t2);
1
2
3
4
5
6
7

5. 线程对象与任务分离

线程对象可以与其任务分离。这对于需要在后台运行的任务非常有用，我们不需要在运行时停止它。

std::thread::detach容许线程从线程句柄独立开来执行，其从 thread 对象分离执行线程，允许执行独立地持续。一旦该线程退出，则释放任何分配的资源。调用 detach 后*this不再占有任何线程。

示例：

#include <iostream>
#include <chrono>
#include <thread>
 
void independentThread() 
{
    std::cout << "Starting concurrent thread.\n";
    std::this_thread::sleep_for(std::chrono::seconds(2));
    std::cout << "Exiting concurrent thread.\n";
}
 
void threadCaller() 
{
    std::cout << "Starting thread caller.\n";
    std::thread t(independentThread);
    t.detach();
    std::this_thread::sleep_for(std::chrono::seconds(1));
    std::cout << "Exiting thread caller.\n";
}
 
int main() 
{
    threadCaller();
    std::this_thread::sleep_for(std::chrono::seconds(5));
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

可能的输出：

Starting thread caller.
Starting concurrent thread.
Exiting thread caller.
Exiting concurrent thread.
1
2
3
4

文章首发公众号：iDoitnow如果喜欢话，可以关注一下