std::thread介绍

最新推荐文章于 2024-04-02 11:45:19 发布
最新推荐文章于 2024-04-02 11:45:19 发布
阅读量1.7k 收藏 11
点赞数 2
分类专栏： C++学习 文章标签： thread用法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/YMWM_/article/details/117969217
版权

目录


  C++中的一个表示执行线程的类。一个执行线程是一个指令序列，它可以在多线程环境中与其它这样的序列同时执行，共享相同的地址空间。一个已经初始化了的线程对象表示正在执行的活动线程，这样的线程对象是joinable（可接合的，不知道翻译的对不对），并且具有唯一的线程id。一个默认构造的（即未初始化的）线程对象是not joinable（不可接合的），其线程id对所有不可接合的线程都是通用的。如果从可接合线程中 移动，或者对其 调用join()或detach()，则可接合线程将变成不可接合的。
  下面以表格的形式介绍了该类的成员变量、成员函数和非成员重载。

成员变量介绍
id线程id
native_handle_type本地句柄类型
成员函数介绍
(constructor)构造线程
（destructor）构析线程
operator=move-assign thread
get_id获得线程id
joinable检查是否可接合的
join加入线程
detach分离线程
swap交换线程
native_handle获得本地句柄
hardware_concurrency检测硬件并发性
非成员重载介绍
swap(thread)交换线程

创建线程

  线程的创建方法有4种，分别介绍如下。

（1）通过函数指针创建

//1 对于无参数的函数
void func() {}
thread th(func);

//2 对于按值传递参数的函数
void func(int a, int b) {}
thread th(func, 1, 2);

//3 对于按址传递参数的函数
void func(int& a, int& b) {}
int val_a = 1, val_b = 2;
thread th(func, ref(val_a), ref(val_b));

//4 对于按值和按址混合传递参数的函数
void func(int a, int b, int& c) {}
int val_c = 3;
thread th(func, 1, 2, ref(val_c));

（2）通过函数对象创建

#include <iostream>
#include <thread>

using namespace std;

class funcObject
{
public:
	funcObject(int a, int b) : a_(a), b_(b) {}
	void operator()() const
	{
		cout << "a_ = " << a_ << ", b_ = " << b_ << endl;
	}
private:
	int a_;
	int b_;
};

int main()
{
	//使用函数对象创建方法1
	thread t1{ funcObject{1, 11} };
	t1.join();

	//使用函数对象创建方法2
	thread t2(funcObject(2, 22));
	t2.join();

	//使用函数对象创建方法3
	funcObject fo(3, 33);
	thread t3(fo);
	t3.join();

	return 0;
}

（3）通过lambda表示式创建

int a = 1, b = 2;
thread t( [a, b]
{
	cout << "a = " << a << ", b = " << b << endl;
} 
);

（4）通过成员函数创建

#include <iostream>
#include <thread>

using namespace std;

class MyClass
{
public:
	MyClass(int a, int b) : a_(a), b_(b) {}
	void func() {cout << "a_ = " << a_ << ", b_ = " << b_ << endl;}
private:
	int a_;
	int b_;	
};

int main()
{
	MyClass mc(1, 2);
	thread t(&MyClass::func, &mc);  //通过成员函数来创建线程
	t.join();
	return 0;
}

成员函数使用

（1）join()

当使用join()函数时，主线程main()被阻塞，等待被调线程th终止，然后主线程main()回收被调线程th资源，并继续运行。演示代码如下，

#include <iostream>
#include <thread>

using namespace std;

void func1() 
{
	int n = 10;
	while(n--)
		cout << "executing func1()..." << endl; 
	cout << "fun1() end!" << endl;
}

int main()
{
	thread th(func1);  //实例化一个线程对象th，该线程开始执行
	th.join();  //如果缺少该语句，则主线程会直接结束，即便子线程th没有执行完！
	cout << "main() end!" << endl;
	return 0;
}

输出结果为，

executing func1()...
executing func1()...
executing func1()...
executing func1()...
executing func1()...
executing func1()...
executing func1()...
executing func1()...
executing func1()...
executing func1()...
fun1() end!
main() end!

（2）detach()

使用detach()函数会使得线程th在后台运行，并且主线程main()不必等待子线程th执行完后才可以退出，还有，即便主线程main()退出之后，子线程th仍旧可在后台运行。示例代码如下，

#include <iostream>
#include <thread>

using namespace std;

void func() 
{
	while(1)
		cout << "func1 is operating a" << endl;
}

int main()
{
	thread th(func);  //实例化一个线程对象th，该线程开始执行
	th.detach();
	cout << "main end()!" << endl;
	return 0;
}

程序运行结果为，

func1 is operating amain end()!

（3）joinable()

用来判断线程是否可以成功使用join()或detach()，返回true或false。在join()或detach()调用之前，返回true；在join()或detach()调用之后返回false。示例代码如下，

#include <iostream>
#include <thread>

using namespace std;

void func() 
{
	int n = 30;
	while(n--)
		cout << "func1 is operating a" << endl;
}

int main()
{
	thread th(func);  //实例化一个线程对象th，该线程开始执行
	cout << "th.joinable() = " << th.joinable() << endl;
	th.join(); //或可以写成th.detach();
	cout << "th.joinable() = " << th.joinable() << endl;
	cout << "main end()!" << endl;
	return 0;
}

程序运行结果为，

func1 is operating ath.joinable() = 1

func1 is operating a
func1 is operating a
func1 is operating a
func1 is operating a
func1 is operating a
func1 is operating a
func1 is operating a
func1 is operating a
func1 is operating a
func1 is operating a
func1 is operating a
func1 is operating a
func1 is operating a
func1 is operating a
func1 is operating a
func1 is operating a
func1 is operating a
func1 is operating a
func1 is operating a
func1 is operating a
func1 is operating a
func1 is operating a
func1 is operating a
func1 is operating a
func1 is operating a
func1 is operating a
func1 is operating a
func1 is operating a
func1 is operating a
th.joinable() = 0
main end()!

（4）get_id()

返回线程id，注意如果返回值为0表示线程对象不可接合。示例代码如下，

#include <iostream>
#include <thread>

using namespace std;

void func1() {}

void func2() {}


int main()
{
	thread th1(func1);  //实例化一个线程对象th1，该线程开始执行
	thread th2(func2);  //实例化一个线程对象th2，该线程开始执行
	cout << "线程th1的id为：" << th1.get_id() << "，线程th2的id为：" << th2.get_id() << endl;
	th1.join();
	th2.join();
	cout << "线程th1的id为：" << th1.get_id() << "，线程th2的id为：" << th2.get_id() << endl;
	cout << "main end()!" << endl;
	return 0;
}

程序运行结果为，

线程th1的id为：23720，线程th2的id为：24636
线程th1的id为：0，线程th2的id为：0
main end()!

（5）swap(·) or swap(·,·)

  什么情况下会使用到交换线程呢？需要对线程进行排序操作时。
  使用方式为

  1. th1.swap(th2);，表示线程th1和线程th2交换。该函数为类的成员函数。
  2. std::swap(th1, th2)，表示线程th1和线程th2交换。该函数为非成员函数重载。

  注意，使用swap()函数之前，必须保证线程对象是可接合的，即joinable() == true，否则会报错！
  示例代码如下，

#include <iostream>
#include <thread>

using namespace std;

void func1() {}
void func2() {}

int main()
{
	thread th1(func1);
	thread th2(func2);

	cout << "th1 id = " << th1.get_id() << "; th2 id = " << th2.get_id() << "!" << endl;

	th1.swap(th2);

	cout << "th1 id = " << th1.get_id() << "; th2 id = " << th2.get_id() << "!" << endl;

	swap(th1, th2);
	cout << "th1 id = " << th1.get_id() << "; th2 id = " << th2.get_id() << "!" << endl;

	th1.join();
	th2.join();

	return 0;
}

程序输出结果为，

th1 id = 9208; th2 id = 14400!
th1 id = 14400; th2 id = 9208!
th1 id = 9208; th2 id = 14400!

不写join()或detach()报错

#include <iostream>
#include <thread>

using namespace std;

void func()
{
	cout << "func() is executed!" << endl;
}

int main()
{
	thread th(func);
	th.join();  //如果注释该行，程序会报错
	return 0;
}

原因是什么呢？这个问题与thread类的构析函数（相关介绍见请点击）有关。thread类的析构函数中，有如下代码块

~thread() noexcept
{	// clean up
	if (joinable())
		_STD terminate();
}

也就是说如果线程对象是可接合的，即joinable() == true，那么将会调用std::terminate()函数，程序报错。
  只有当线程对象是不可接合的，即joinable() == false，也就是说，

  • it was default-constructed
  • it was moved from
  • join() has been called
  • detach() has been called

那么该线程对象才可以被安全销毁，也即析构函数可以被成功执行。

mutex

基本使用

  互斥量，需要包含头文件#include<mutex>，作用是防止不同的线程同时操作同一个共享数据。另一点就是使得线程的执行有了先后顺序，必须等待线程th1结束之后，线程th2才会运行。
  考虑这样一个问题：有全局变量a，函数void func1()和函数void func2()都需要使用变量a，在主线程中main()中启用线程th1执行函数func1，启用线程th2执行函数func2。分析：由于函数func1和函数func2运行在不同线程中的，所以可能会出现两者同时对变量a进行操作的情况，因此，需要定义一个互斥量变量m，即mutex m;，在函数func1和函数func2的开始时上锁m.lock()和结尾时解锁m.unlock()。示例代码如下，

#include <iostream>
#include <thread>
#include <mutex>

using namespace std;

int a;
mutex m;

void func1() 
{
	m.lock();
	cout << "operating a" << endl;
	m.unlock();
}

void func2()
{
	m.lock();
	cout << "operating a" << endl;
	m.unlock();
}


int main()
{
	thread th1(func1);  //实例化一个线程对象th1，该线程开始执行
	thread th2(func2);  //实例化一个线程对象th2，该线程开始执行
	th1.join();
	th2.join();
	cout << "main end()!" << endl;
	return 0;
}

程序运行结果为，

operating a
operating a
main end()!

进阶

  使用m.lock()和m.unlock()来保证数据不会被同时访问，这种方法有一定的缺陷。比如，如果在func1函数中m.lock()之后函数异常退出，那么由于没有对互斥量m解锁（即，m.unlock()），func2函数将无法访问变量a，线程th2被堵塞。如下异常代码所示，

#include <iostream>
#include <thread>
#include <mutex>

using namespace std;

int a;
mutex m;

void func1() 
{
	m.lock();
	cout << "operating a" << endl;
	return;  //func1函数在m.unlock()之前退出
	m.unlock();
}

void func2()
{
	m.lock();  //线程th2被阻塞
	cout << "operating a" << endl;
	m.unlock();
}


int main()
{
	thread th1(func1);  //实例化一个线程对象th1，该线程开始执行
	thread th2(func2);  //实例化一个线程对象th2，该线程开始执行
	th1.join();
	th2.join();
	cout << "main end()!" << endl;
	return 0;
}

  因此，一般使用lock_guard<mutex> l(m);或unique_lock<mutex> l(m);来代替m.lock(); m.unlock();。

#include <iostream>
#include <thread>
#include <mutex>

using namespace std;

int a;
mutex m;

void func1() 
{
	lock_guard<mutex> l(m);  //或写成unique_lock<mutex> l(m);
	cout << "operating a" << endl;
	return;  
}

void func2()
{
	lock_guard<mutex> l(m);  //或写成unique_lock<mutex> l(m);
	cout << "operating a" << endl;
}


int main()
{
	thread th1(func1);  //实例化一个线程对象th1，该线程开始执行
	thread th2(func2);  //实例化一个线程对象th2，该线程开始执行
	th1.join();
	th2.join();
	cout << "main end()!" << endl;
	return 0;
}

程序输出为，

operating a
operating a
main end()!

参考

  1. http://www.cplusplus.com/reference/thread/thread/?kw=thread
  2. https://en.cppreference.com/w/Main_Page
  3. https://blog.csdn.net/weixin_40087851/article/details/82685510?utm_medium=distribute.pc_relevant_t0.none-task-blog-2%7Edefault%7EBlogCommendFromMachineLearnPai2%7Edefault-1.control&depth_1-utm_source=distribute.pc_relevant_t0.none-task-blog-2%7Edefault%7EBlogCommendFromMachineLearnPai2%7Edefault-1.control
  4. https://blog.csdn.net/myruo/article/details/89370445
  5. https://blog.csdn.net/me1171115772/article/details/106952308
  6. https://blog.csdn.net/weixin_44862644/article/details/115765250
  7. https://blog.csdn.net/qq_36784975/article/details/87699113
  8. https://blog.csdn.net/wxc971231/article/details/105979443
YMWM_
关注
  • 2
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C++11 多线程（std::thread）详解
jcShan709的博客
07-17 10万+
注：此教程以 Visual Studio 2019 Version 16.10.3 （MSVC 19.29.30038.1) 为标准 文章目录线程？进程？多线程？什么是多线程？进程与线程的区别C++11的std::threadstd::thread常用成员函数构造&析构函数常用成员函数举个栗子例一：thread的基本使用例二：thread执行有参数的函数例三：thread执行带有引用参数的函数注意事项（剩下的内容还没写完，明天再更） 线程？进程？多线程？ 什么是多线程？ 百度百科中的解释： 多.
C++ thread线程库
最新发布
m0_50502677的博客
07-01 852
简单介绍了thread库的类对象和类方法
C++ std::thread使用
mayue_web的博客
10-16 1万+
C++ std::thread 使用
C++std::thread
OneOnce的专栏
07-05 3069
多线程
std::thread
积累点滴，保持自我
08-19 1404
本文转载自：https://github.com/forhappy/Cplusplus-Concurrency-In-Practice/blob/master/zh/chapter3-Thread/Introduction-to-Thread.md 本节将详细介绍std::thread的用法。 std::thread在<thread>头文件中声明，因此使用std::thread需包含<thread>头文件。 <thread>头文件摘要 <...
std::bind和std::thread使用
CSDN爱好者的独到见解
09-29 1010
在这个例子中，我们使用std::bind创建了一个新的函数对象add5，它将add函数的第一个参数绑定到了值5上。std::bind是一个c++标准库函数模板，通过将参数绑定到可调用实体(函数或成员函数)，用于创建可调用对象(函数对象)。在这个例子中，我们使用std::bind创建了一个新的函数对象subtractReordered，它在调用subtract函数时交换了参数的顺序。无论绑定的是类成员函数还是非成员函数，std::bind都允许自定义参数，重新排序，并使用特定的参数绑定创建可调用对象。
std::thread和std::this_thread的详细说明
咸鱼爱幻想的博客
03-11 3173
std::thread类来表示执行的各个线程。执行线程是实际上是执行一系列指令，可以在多线程环境中与其他此类序列同时执行，同时共享相同的地址空间。 std::this_thread命名空间包含了对当前线程的一些基本操作，如获取当前线程id、休眠当前线程、让渡当前线程的时间片给其他线程等。
C++：std::thread：线程用法
C++ JAVA的专栏
01-06 7801
C++：std::thread：线程用法
C++11 std::thread
程序员Link
01-18 3264
一 简介 1、头文件&lt;thread&gt; 2、 thread标识单个执行线程，线程允许多个函数并发执行。 在默认构造、移动、detach或join后，std::thread对象会处在不表示任何线程的状态。detach之后，执行线程可能不关联到任何thread对象。成员类 std::thread::id ，是轻量的频繁复制类，作为std::thread对象的唯一标识符工作。 二 函数 ...
C++多线程：std::thread与std::async对比（十一）
weixin_43808717的博客
04-02 1009
std::thread是C++11中提供的创建线程的一个手段，它是在<thread>头文件中，它的返回值是一个线程主体对象，主要提供下面几个函数join：调用该指令所在的线程阻塞，等待被调用线程的执行完毕detach：调用该指令所在的线程与被调用线程分离，无须管理被调用线程的生死joinable：判断线程是否可以join和detach，因为这两个方法只能调用一次native_handle：获得句柄，应该是线程执行的入口函数get_id：获取线程id。
C++中的reverse()函数
热门推荐
YMWM_的博客
04-06 6万+
实现翻转数组，字符串，向量！ 1翻转数组 //头文件 #include <algorithm> //使用方法 reverse(a, a+n);//n为数组中的元素个数 示例代码， #include <iostream> #include <algorithm> using namespace std; void MyShow(int a[], int n) { for(int i = 0; i < n; i++) cout <&l
结构体排序的三种方式
YMWM_的博客
03-23 1万+
结构体排序方法
C++中如何查询map中是否存在某个元素
YMWM_的博客
04-06 9719
//1 利用count #include <unordered_map> unordered_map<string, int> dist; dist.count(x) == 1;//x元素存在 dist.count(x) == 0;//x元素不存在 //2 利用find dist.find(x) != dist.end();//x元素存在 dist.find(x) == dist.end();//x元素不存在 //3 利用迭代器遍历 unordered_map<string,
c++保留两位有效数字和保留小数点后两位
YMWM_的博客
04-30 4286
  演示代码如下： #include <iostream> #include <iomanip> using namespace std; int main() { double a = 123.345; cout << "正常输出为：" << a << endl; cout << "保留两位有效数字：" << setprecision(2) << a <&
C++中计算迭代器之间的距离 distance
YMWM_的博客
08-20 3569
C++中计算迭代器之间的距离 distance
C++判断两个double数相等不能用==
YMWM_的博客
08-29 2774
  浮点数在内存中的存储有舍入误差，在计算机中用近似表示任意某个实数。比如， double val1 = 4.0; double val2 = 0.1; double a = val1 - val2; 你认为a应该等于3.9，实际在计算机中它却是3.899999999999999999999。   所以不能用==来判断两个double是否相等，而是， const double eps = 1e-8; if(abs(a-b) <= eps) 相等 else 不相等 ...
使用哈希表统计数组中数字出现的次数
YMWM_的博客
02-25 2717
#include <iostream> #include <map> using namespace std; int main() { int array[11] = {1, 2, 3, 3, 3, 4, 4, 5, 5, 5, 5}; map<int, int, less<int>> hash; //less表示该哈希表中小数字的次数，再存放大数字的次数。在此处就是，现存放数组中1出现的次数，在存放数
C++中负数的二进制表示
YMWM_的博客
02-23 2613
比如字符型-5，它的二进制表示如下， 第1步：先写出整型5的二进制表示【0000,0101】 第2步：取反加1就是整型-5的二进制表示【1111,1011】
C++代码库cppsqlite3使用技巧
YMWM_的博客
06-06 2181
C++代码库cppsqlite3使用技巧
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

YMWM_

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值