02 | C++ 线程的使用

C++11 中提供的线程类叫做 std::thread，基于这个类创建一个新的线程非常的简单，只需要提供线程函数或者函数对象即可，并且可以同时指定线程函数的参数。我们首先来了解一下这个类提供的一些常用 API：

构造函数

---

// ①
thread() noexcept;
// ②
thread( thread&& other ) noexcept;
// ③
template< class Function, class... Args >
explicit thread( Function&& f, Args&&... args );
// ④
thread( const thread& ) = delete;

公共成员函数

---

get_id()

这个获取线程 ID 的函数叫做 get_id()，函数原型如下：

std::thread::id get_id() const noexcept;

示例程序如下：

#include <iostream>
#include <thread>
#include <chrono>
#include <string>
using namespace std;
 
void func(int num, string str)  //任务函数 func() 一般返回值指定为 void，因为子线程在调用这个函数的时候不会处理其返回值
{
	for (int i = 0; i < 10; ++i)
	{
		cout << "子线程: i = " << i << "num: "
			<< num << ", str: " << str << endl;
	}
}
 
void func1()
{
	for (int i = 0; i < 10; ++i)
	{
		cout << "子线程: i = " << i << endl;
	}
}
 
int main()
{
	cout << "主线程的线程ID: " << this_thread::get_id() << endl;
	thread t(func, 520, "i love you"); //func() 是一个回调函数，线程启动之后就会执行这个任务函数，程序猿只需要实现即可
	thread t1(func1);
	cout << "线程t 的线程ID: " << t.get_id() << endl;
	cout << "线程t1的线程ID: " << t1.get_id() << endl;
	getchar();
}
 

结果很混乱

默认情况下，主线程销毁时会将与其关联的两个子线程也一并销毁，但是这时有可能子线程中的任务还没有执行完毕，最后也就得不到我们想要的结果了。

当启动了一个线程（创建了一个 thread 对象）之后，在这个线程结束的时候（std::terminate ()），我们如何去回收线程所使用的资源呢？thread 库给我们两种选择：

• 加入式（join()）
• 分离式（detach()）

另外，我们必须要在线程对象销毁之前在二者之间作出选择，否则程序运行期间就会有 bug 产生。

join

• join() 字面意思是连接一个线程，意味着主动地等待线程的终止（线程阻塞）。在某个线程中通过子线程对象调用
• join() 函数，调用这个函数的线程被阻塞，但是子线程对象中的任务函数会继续执行，当任务执行完毕之后
• join() 会清理当前子线程中的相关资源然后返回，同时，调用该函数的线程解除阻塞继续向下执行。

函数在哪个线程中被执行，那么函数就阻塞哪个线程。

如果要阻塞主线程的执行，只需要在主线程中通过子线程对象调用这个方法即可，当调用这个方法的子线程对象中的任务函数执行完毕之后，主线程的阻塞也就随之解除了。修改之后的示例代码如下：

int main()
{
    cout << "主线程的线程ID: " << this_thread::get_id() << endl;
    thread t(func, 520, "i love you");
    thread t1(func1);
    cout << "线程t 的线程ID: " << t.get_id() << endl;
    cout << "线程t1的线程ID: " << t1.get_id() << endl;
    t.join();  
    //如果任务函数 func() 还没执行完毕，主线程阻塞，直到任务执行完毕，主线程解除阻塞，继续向下运行
    //如果任务函数 func() 已经执行完毕，主线程不会阻塞，继续向下运行
    t1.join();
}

detach()

detach() 函数的作用是进行线程分离，分离主线程和创建出的子线程。在线程分离之后，主线程退出也会一并销毁创建出的所有子线程，在主线程退出之前，它可以脱离主线程继续独立的运行，任务执行完毕之后，这个子线程会自动释放自己占用的系统资源。（其实就是孩子翅膀硬了，和家里断绝关系，自己外出闯荡了，如果家里被诛九族还是会受牵连）。该函数函数原型如下：

注意事项：线程分离函数 detach () 不会阻塞线程，子线程和主线程分离之后，在主线程中就不能再对这个子线程做任何控制了，比如：通过 join () 阻塞主线程等待子线程中的任务执行完毕，或者调用 get_id () 获取子线程的线程 ID。有利就有弊，鱼和熊掌不可兼得，建议使用 join ()。

joinable()

joinable() 函数用于判断主线程和子线程是否处理关联（连接）状态，一般情况下，二者之间的关系处于关联状态，该函数返回一个布尔类型：

bool joinable() const noexcept;

示例代码

#include <iostream>
#include <thread>
#include <chrono>
using namespace std;
 
void foo()
{
    this_thread::sleep_for(std::chrono::seconds(1));
}
 
int main()
{
    thread t;
    cout << "before starting, joinable: " << t.joinable() << endl;
 
    t = thread(foo);
    cout << "after starting, joinable: " << t.joinable() << endl;
 
    t.join();
    cout << "after joining, joinable: " << t.joinable() << endl;
 
    thread t1(foo);
    cout << "after starting, joinable: " << t1.joinable() << endl;
    t1.detach();
    cout << "after detaching, joinable: " << t1.joinable() << endl;
}

可以得到以下结论：

• 在创建的子线程对象的时候，如果没有指定任务函数，那么子线程不会启动，主线程和这个子线程也不会进行连接
• 在创建的子线程对象的时候，如果指定了任务函数，子线程启动并执行任务，主线程和这个子线程自动连接成功
• 子线程调用了detach()函数之后，父子线程分离，同时二者的连接断开，调用joinable()返回false
• 在子线程调用了join()函数，子线程中的任务函数继续执行，直到任务处理完毕，这时join()会清理（回收）当前子线程的相关资源，所以这个子线程和主线程的连接也就断开了，因此，调用join()之后再调用joinable()会返回false。

operator=

线程中的资源是不能被复制的，因此通过 = 操作符进行赋值操作最终并不会得到两个完全相同的对象。

// move (1)	
thread& operator= (thread&& other) noexcept;
// copy [deleted] (2)	
thread& operator= (const other&) = delete;

静态函数

thread 线程类还提供了一个静态方法，用于获取当前计算机的 CPU 核心数，根据这个结果在程序中创建出数量相等的线程，每个线程独自占有一个CPU核心，这些线程就不用分时复用CPU时间片，此时程序的并发效率是最高的。

static unsigned hardware_concurrency() noexcept;

示例代码

#include <iostream>
#include <thread>
using namespace std;
 
int main()
{
    int num = thread::hardware_concurrency();
    cout << "CPU number: " << num << endl;
}

参考

爱编程的大丙 https://subingwen.cn/cplusplus/