C++多线程学习笔记09（std::future、std::shared_future、std::atomic原子操作）

最新推荐文章于 2022-09-03 09:09:39 发布
最新推荐文章于 2022-09-03 09:09:39 发布
阅读量581 收藏
点赞数
分类专栏： C++多线程 文章标签： c++ visual studio cocos2d
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43142607/article/details/122523134
版权

一、std::future的其他成员函数
//枚举类型：wait_for

// 线程8.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include<future>
#include<thread>
#include<iostream>
using namespace std;
#include<vector>
int mythread(int mypar)
{
	cout << "mypar = " << mypar << endl;
	cout << "mythread() start " << "threadid = " << std::this_thread::get_id() << endl;
	std::chrono::milliseconds dura(5000);
	std::this_thread::sleep_for(dura);
	cout << "mythread() end " << "threadid = " << std::this_thread::get_id() << endl;
	return 5;
}
int main()
{
	cout << "main " << "threadid = " << std::this_thread::get_id() << endl;
	std::future<int> result = std::async(std::launch::deferred,mythread,5);  //创建一个线程开始执行，绑定关系，流程不卡在这
	cout << "contine...." << endl;
	int def = 0;
	//cout << result.get() << endl;  //卡在这里等待mythread()执行完毕，拿到返回值  自能调用一次
	//result.wait();//等待线程返回，本身不返回结果
	
	//一、std::future的其他成员函数
	//枚举类型：wait_for
	std::future_status status = result.wait_for(std::chrono::seconds(0));//等待一秒
	if (status == std::future_status::timeout)
	{
		cout << "超时" << endl;
	}
	else if (status == std::future_status::ready)
	{
		cout << "线程成功执行完毕，返回" << endl;
		cout << result.get() << endl;
	}
	else if (status == std::future_status::deferred)
	{
		cout << "线程被延迟执行" << endl;
		cout << result.get() << endl;
	}

	return 0;
}

二、std::shared_future类模板

// 线程8.cpp : 定义控制台应用程序的入口点。
//
#include "stdafx.h"
#include<future>
#include<thread>
#include<iostream>
using namespace std;
#include<vector>
int mythread(int mypar)
{
	cout << "mypar = " << mypar << endl;
	cout << "mythread() start " << "threadid = " << std::this_thread::get_id() << endl;
	std::chrono::milliseconds dura(5000);
	std::this_thread::sleep_for(dura);
	cout << "mythread() end " << "threadid = " << std::this_thread::get_id() << endl;
	return 5;
}
void mythread2(std::shared_future<int>&tmpf)
{
	cout << "mythread2() start" << "  threadid = " << std::this_thread::get_id() << endl;
	auto result = tmpf.get();
	cout << " mythread2 result = " << result << endl;
	
}
int main()
{
	//二、std::shared_future类模板，get()函数是复制数据
	cout << "main " << "threadid = " << std::this_thread::get_id() << endl;
	std::packaged_task<int(int)>mypt(mythread);
	std::thread t1(std::ref(mypt),1);
	t1.join();
	/*01
	std::future<int> result = mypt.get_future();
	bool ifcan = result.valid();
	//std::shared_future<int> result_s(std::move(result)); 
	std::shared_future<int> result_s(result.share());//执行完毕后result_s里面有值，result里面空
	bool ifcan1 = result.valid();
	auto mythreadresult = result_s.get();
	mythreadresult = result_s.get();  //get多次
	*/
	//02
	std::shared_future<int> result_s(mypt.get_future());//通过get_future返回值直接构造一个shared_future对象
	auto mythreadresult = result_s.get();
	mythreadresult = result_s.get();  //get多次
	
	std::thread t2(mythread2,std::ref(result_s));
	t2.join();
	return 0;
}

三、原子操作std::atomic 类模板 封装某个值
互斥量：多线程编程中 保护共享数据；锁，操作共享数据
有两个线程，一个线程读变量值，一个线程写值
原子操作理解：不需要用到互斥量加锁（无锁），技术的多线程并发编程方式
原子操作：是在多线程中，不会被打断的 程序执行片段； 比互斥量更高效率
互斥量加锁一般为一个代码段，而原子操作一般都是一个变量
原子操作，一般指”不可分割的操作“，也就是说这种操作要么完成，要么没完成，不可能出现半完成状态。

正常加有问题

// 线程8.cpp : 定义控制台应用程序的入口点。
//
#include "stdafx.h"
#include<future>
#include<thread>
#include<iostream>
using namespace std;
#include<vector>
//std::atomic<int> g_mycount = 0;//定义一个全局变量
//std::mutex g_my_mutex;
int g_mycount = 0;
void mythread() //线程入口函数
{
	for (int i = 0;i<1000000;i++)
	{
		//g_my_mutex.lock();
		g_mycount++;              //加时会被打断
		//g_my_mutex.unlock();
		//g_mycount++;//对应的操作是原子操作，不会被打断
	}
}
int main()
{
	thread myobj1(mythread);
	thread myobj2(mythread);
	myobj1.join();
	myobj2.join();
	cout << "两个线程执行完毕 结果 = " << g_mycount << endl;
	return 0;
}

两个线程执行完毕 结果 = 1207351
请按任意键继续. . .
不等于2000000

带互斥量效率低

// 线程8.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include<future>
#include<thread>
#include<iostream>
using namespace std;
#include<vector>
//std::atomic<int> g_mycount = 0;//定义一个全局变量
std::mutex g_my_mutex;
int g_mycount = 0;
void mythread() //线程入口函数
{
	for (int i = 0;i<1000000;i++)
	{
		g_my_mutex.lock();
		g_mycount++;
		g_my_mutex.unlock();

		//g_mycount++;//对应的操作是原子操作，不会被打断
	}
}
int main()
{
	thread myobj1(mythread);
	thread myobj2(mythread);
	myobj1.join();
	myobj2.join();
	cout << "两个线程执行完毕 结果 = " << g_mycount << endl;
	return 0;
}

两个线程执行完毕 结果 = 2000000
请按任意键继续. . .

原子操作std::atomic

// 线程8.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include<future>
#include<thread>
#include<iostream>
using namespace std;
#include<vector>
std::atomic<int> g_mycount = 0;//定义一个全局变量
//std::mutex g_my_mutex;
//int g_mycount = 0;
void mythread() //线程入口函数
{
	for (int i = 0;i<1000000;i++)
	{
		/*g_my_mutex.lock();
		g_mycount++;
		g_my_mutex.unlock();*/

		g_mycount++;//对应的操作是原子操作，不会被打断
	}
}
int main()
{	
	thread myobj1(mythread);
	thread myobj2(mythread);
	myobj1.join();
	myobj2.join();
	cout << "两个线程执行完毕 结果 = " << g_mycount << endl;
	return 0;
}

两个线程执行完毕 结果 = 2000000
请按任意键继续. . .

// 线程8.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include<future>
#include<thread>
#include<iostream>
using namespace std;
#include<vector>

std::atomic<bool>g_ifend = false;
void mythread()
{
	std::chrono::microseconds dura(1000);
	while (g_ifend == false)
	{
		cout << "thread id = " << std::this_thread::get_id()<<"运行中" << endl;
		std::this_thread::sleep_for(dura);
	}
	cout << "thread id = " << std::this_thread::get_id() << "运行结束" << endl;
}

int main()
{
	thread myobj1(mythread);
	thread myobj2(mythread);
	std::chrono::microseconds dura(5000);
	std::this_thread::sleep_for(dura);
	g_ifend = true;
	myobj1.join();
	myobj2.join();
	cout << "程序退出" << endl;

	return 0;
}

原子操作写的方法

// 线程8.cpp : 定义控制台应用程序的入口点。
//
#include "stdafx.h"
#include<future>
#include<thread>
#include<iostream>
using namespace std;
#include<vector>
std::atomic<bool>g_ifend = false;
void mythread()
{
	std::chrono::microseconds dura(1000);
	while (g_ifend == false)
	{
		cout << "thread id = " << std::this_thread::get_id()<<"运行中" << endl;
		std::this_thread::sleep_for(dura);
	}
	cout << "thread id = " << std::this_thread::get_id() << "运行结束" << endl;
}

int main()
{
	thread myobj1(mythread);
	thread myobj2(mythread);
	std::chrono::microseconds dura(10000);
	std::this_thread::sleep_for(dura);
	g_ifend = true;  //原子操作，不想被打断
	myobj1.join();
	myobj2.join();
	cout << "程序退出" << endl;
	return 0;
}

hread id = 17836运行中
thread id = 16676运行中
thread id = 16676运行中
thread id = 17836运行中
thread id = 17836运行中
thread id = 16676运行结束
thread id = 17836运行结束
程序退出
请按任意键继续. . .

一生只爱何
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++11并发与多线程笔记（10） future其他成员函数、shared_future、atomic
qq_38231713的博客
05-13 3048
第十节 future其他成员函数、shared_future、atomic 一、std::future 的成员函数 1、std::future_status status = result.wait_for(std::chrono::seconds(几秒)); 卡住当前流程，等待std::async()的异步任务运行一段时间，然后返回其状态std::future_status。如果std::async()的参数是std::launch::deferred（延迟执行），则不会卡住主流程。 std::futu
我们使std :: shared_mutex快10倍
04-11
标题中的“我们使std::shared_mutex快10倍”揭示了一个关于C++多线程并发编程的优化案例，其中std::shared_mutex是C++11引入的一种互斥锁，用于支持读写锁，允许多个读取者同时访问共享资源而只允许一个写入者。...
C++11 并发指南四(<future> 详解三 std::future & std::shared_future)
weixin_33849215的博客
08-27 703
上一讲《C++11 并发指南四(&lt;future&gt; 详解二 std::packaged_task 介绍)》主要介绍了 &lt;future&gt; 头文件中的 std::packaged_task 类，本文主要介绍 std::future，std::shared_future 以及 std::future_error，另外还会介绍 &lt;future&gt; 头文件中的 std::as...
C++ 并发指南＜ future ＞（3）std::future & std::shared_future
qq_24649627的博客
03-02 498
std::future介绍 简单地说，std::future 可以用来获取异步任务的结果，因此可以把它当成一种简单的线程间同步的手段。 std::future 通常由某个 Provider 创建，你可以把 Provider 想象成一个异步任务的提供者，Provider 在某个线程中设置共享状态的值，与该共享状态相关联的 std::future 对象调用 get（通常在另外一个线程中） 获取该值，如果共享状态的标志不为 ready，则调用 std::future::get 会阻塞当前的调用者，直到 Provi
std::shared_future
小米的修行之路
07-24 641
在之前我们了解了class std::future,但是通过class std::future获得的结果只能get()一次,第二次调用就会产生不可预期的结果，通常会抛出一个std::future_error. 但是当多个其他线程也想处理这份结果，也就是想多次get(),基于这个目的C++ standard library提供了class std::shared_future,于是我们就可以多次调...
《C++ Concurrency in Action》笔记18 std::shared_future
t114211200的博客
09-25 930
std::future有个限制，那就是只能被一个线程等待。如果你希望从多个线程等待一个相同的事件，那就应该使用std::shared_future。 等待多个线程 尽管future对数据从一个线程到另一个线程传送作了所有的必要处理，但是调用同一个future实例的成员函数的不同线程却不会彼此同步。如果你访问单一的来自多个线程的fuure实例，没有附加的同步手段，那么你将导致数据竞争。因为，一个
线程安全的std :: map和无锁映射的速度
04-11
2. **无锁编程**：无锁编程（Lock-free Programming）是一种优化多线程并发性能的技术，它避免了线程间的互斥锁定，通过原子操作（如std::atomic）来更新数据，从而减少锁竞争，提高系统效率。无锁映射（Lock-free ...
C++ 11 开发中的 Atomic 原子操作.rar_C++11、原子_atomic c++_c++ atomic使用_c++
09-23
C++11引入了原子操作（Atomic Operations）作为标准库的一部分，这为多线程编程提供了重要的支持。原子操作在并发环境下确保了数据的完整性，防止了数据竞争和其他并发问题。下面将详细介绍C++11中`std::atomic`的...
atomic_queue：C ++无锁队列
01-28
atomic_queue 基于带有循环缓冲区的C ++ 14多生产者多消费者无锁队列。 这些队列遵循的主要设计原理是极简主义：原子操作的最基本要求，固定大小的缓冲区，值语义。 这些品质也有局限性： 最大队列大小必须在编译...
Linux操作系统课程指导：Ch12MemoryManagement.pptx
11-13
Linux操作系统中的内存管理是系统设计的关键部分，它确保了高效且可靠的资源利用。在本章中，我们将深入探讨Linux内存管理的多个方面。 首先，内存管理的基础是分页（Paging）和页表（Page Table）。分页是将内存...
c++11：std::shared_future
李白
10-09 482
类模板 std::shared_future 提供访问异步操作结果的机制，类似 std::future ，除了允许多个线程等候同一共享状态。不同于仅可移动的 std::future （故只有一个实例能指代任何特定的异步结果），std::shared_future 可复制而且多个 shared_future 对象能指代同一共享状态。 若每个线程通过其自身的 shared_future 对象副本访问，则从多个线程访问同一共享状态是安全的。 shared_future 可用于同时向多个线程发信，类似 std.
c++多线程（十五） - std::shared_future
万里归来少年心
05-02 5495
1. std::future future是类模板，future对象里面含有线程执行的结果，可以通过调用函数get()来获取结果。但是，get()函数的设计包含移动语义，即只能调用一次，第二次调用时会报异常。 #include<iostream> #include<future> using namespace std; int myThread(int n...
c++11 多线程支持 （std::shared_future）
qq_40788199的博客
09-03 1598
类模板 std::shared_future 提供访问异步操作结果的机制，类似 std::future ，除了允许多个线程等候同一共享状态。不同于仅可移动的 std::future （故只有一个实例能指代任何特定的异步结果），std::shared_future 可复制而且多个 shared_future 对象能指代同一共享状态。 若每个线程通过其自身的 shared_future 对象副本访问，则从多个线程访问同一共享状态是安全的。
C++，std::shared_future的使用
weixin_30682127的博客
10-25 145
今天给大家分享一个类似多线程任务的方法，具体如下： std::shared_future<int> tmp = std::async(p1,p2,p3); int tmpInt = tmp.get(); 1、std::future是一个非常有用也很有意思的东西，简单说std::future提供了一种访问异步操作结果的机制。 2、std::async代替线程的创建； ...
C++标准库笔记-多线程-shared_future-future的补充扩展
黑山老妖的博客
05-16 1149
std::shared_future 在之前笔记C++11笔记-多线程-细说Future中，std::future提供了“处理并发运算之未来结果”的能力，但是只能处理一次结果，第二次调用get()会导致不可以预期的行为；因为调用get()后会将future的state状态置为无效状态； 在项目的不同场景中，也会有多次处理“并发运算之未来结果”的情况，特别是当多个其他线程都想处理这份结果时。所有C++标准库提供了std::shared_future，可以多次调用get()，产生相同结果或获得任务抛出的异常；
C++11多线程(七):《<future> 详解三：std::future & std::shared_future》
ceasadan的博客
01-05 1416
参考连接： http://www.cnblogs.com/haippy/p/3280643.html 不错的博客 http://www.cplusplus.com/reference/future/future/ cplusplus官网 目录 1.std::future 介绍 2.std::future 构造函数 3.std::future::share() 4.std:
C++11中std::shared_future的使用
热门推荐
网络资源是无限的
01-30 1万+
C++11中的std::shared_future是个模板类。与std::future类似，std::shared_future提供了一种访问异步操作结果的机制；不同于std::future，std::shared_future允许多个线程等待同一个共享状态；不同于std::future仅支持移动操作，std::shared_future既支持移动操作也支持拷贝操作，而且多个shared_futu...
C++11并发与多线程笔记（10）future其他成员函数、shared_future、atomic
badmanWang的博客
11-06 399
文章目录1、std::future的其他成员函数1.1 std::future_status1.2 wait_for()1.3 示例代码2、std::shared_future2.1 get_future()2.2 share()2.3 valid()2.4 示例代码：3、原子操作std::atomic3.1 原子操作概念引出范例3.2 基本的std::atomic用法范例 1、std::future的其他成员函数 1.1 std::future_status 枚举类，用来表示future的返回状态 /
C++并发与多线程(九)future_status、shared_future、atomic
Electro1ux的博客
02-01 333
文章目录future_statusstd::shared_futurestd::atomic future_status std::future_status status = result.wait_for(std::chrono::seconds(1)); //等待1s 卡住当前流程，等待std::async()的异步任务运行一段时间，然后返回其状态std::future_status。如果std::async()的参数是std::launch::deferred（延迟执行），则不会卡住主流程。 std
C++ 11 使用std::atomic_ref
最新发布
05-26
C++11引入了std::atomic_ref，它是std::atomic的一个变种，允许对现有对象进行原子操作，而不是只能用于原子类型。这意味着可以使用std::atomic_ref来实现线程安全的访问非原子类型，例如STL容器中的元素。 使用std...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值