10.future其他成员函数、shared_future、atomic

最新推荐文章于 2023-04-06 21:53:00 发布
最新推荐文章于 2023-04-06 21:53:00 发布
阅读量231 收藏
点赞数
分类专栏： C++ 11 并发与多线程 文章标签： c++ 多线程 并发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42636062/article/details/120250729
版权

目录

在这里插入图片描述

一、std::future 的成员函数

std::future_status status = result.wait_for(std::chrono::seconds(几秒));
卡住当前流程，等待std::async()的异步任务运行一段时间，然后返回其状态std::future_status。如果std::async()的参数是std::launch::deferred（延迟执行），则不会卡住主流程。
std::future_status是枚举类型，表示异步任务的执行状态。类型的取值有
std::future_status::timeout
std::future_status::ready
std::future_status::deferred

代码一：std::future_status的简答使用示范

#include <iostream>
#include <future>
using namespace std;

int mythread() {
	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(mythread);
	cout << "continue........" << endl;
	//cout << result1.get() << endl; //卡在这里等待mythread()执行完毕，拿到结果
	//等待1秒
	std::future_status status = result.wait_for(std::chrono::seconds(1));
	if (status == std::future_status::timeout) {
		//超时：表示线程还没有执行完
		cout << "超时了，线程还没有执行完" << endl;
	}
	//类成员函数
	return 0;
}

在这里插入图片描述

代码二：三种情况的详细示范

​ 着重看future_status中deferred如何使用

​ 要使用std::future<int> result = std::async(std::launch::deferred, mythread);

#include <iostream>
#include <future>
using namespace std;

int mythread() {
	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);
	//std::future<int> result = std::async(mythread);
	cout << "continue........" << endl;
	//cout << result1.get() << endl; //卡在这里等待mythread()执行完毕，拿到结果
	std::future_status status = result.wait_for(std::chrono::seconds(6));
	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) {
		//如果设置 std::future<int> result = std::async(std::launch::deferred, mythread);，则本条件成立
		cout << "线程延迟执行" << endl;
		cout << result.get() << endl;
	}

	cout << "good luck" << endl;
	return 0;
}

在这里插入图片描述

其中，get()只能使用一次！！！

//像这种如果这样写就错误！
auto a = result.get();
cout << result.get() << endl;

这样就会就会报告异常
因为get()函数的设计是一个移动语义，相当于将result中的值移动到了a中，再次get就报告了异常。

二、std::shared_future：也是个类模板

std::future的 get() 成员函数是转移数据

std::shared_future 的 get()成员函数是复制数据

代码一：简化版本

#include <iostream>
#include <thread>
#include <future>
using namespace std;

int mythread() {
	cout << "mythread() start" << "threadid = " << std::this_thread::get_id() << endl;
	//std::this_thread::sleep_for(chrono::seconds(5));
	cout << "mythread() end" << "threadid = " << std::this_thread::get_id() << endl;
	return 5;
}


int main() {
    /*---------------------------------
        错 误 示 范：
     ----------------------------------*/ 
    //future<int> result_s= async(mythread2);   会报错，因为std::future的 get() 成员函数是转移数据
    /*---------------------------------
        解 决 办 法，1.改 shared_future
     ----------------------------------*/ 
	shared_future<int> result_s= async(mythread2);
	cout << result_s.get() << endl;
	cout << result_s.get() << endl;
    
     /*------------------------------------------------
        解 决 办 法，
        2.改 将future里的result所有权转移给shareed_future里
     ---------------------------------------------------*/ 
    future<int> result = async(mythread2);
	shared_future<int> result_s(result.share());
	cout << result_s.get() << endl;
	cout << result_s.get() << endl;
	
    
    return 0;
}

代码二：示范案例二

#include <thread>
#include <iostream>
#include <future>
using namespace std;
 
int mythread() {
	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::packaged_task<int()> mypt(mythread);
	std::thread t1(std::ref(mypt));
	std::future<int> result = mypt.get_future();
	
	bool ifcanget = result.valid(); //判断future 中的值是不是一个有效值
	std::shared_future<int> result_s(result.share()); //执行完毕后result_s里有值，而result里空了
	//std::shared_future<int> result_s(std::move(result));
   //通过get_future返回值直接构造一个shared_future对象
   //std::shared_future<int> result_s(mypt.get_future());
   t1.join();
	
	auto myresult1 = result_s.get();
	auto myresult2 = result_s.get();
 
	cout << "good luck" << endl;
	return 0;
}

在这里插入图片描述

三、std::atomic原子操作

3.1 原子操作概念引出范例

互斥量：多线程编程中 用于保护共享数据：先锁住， 操作共享数据， 解锁。

有两个线程，对一个变量进行操作，一个线程读这个变量的值，一个线程往这个变量中写值。

即使是一个简单变量的读取和写入操作，如果不加锁，也有可能会导致读写值混乱（一条C语句会被拆成3、4条汇编语句来执行，所以仍然有可能混乱）

#include <iostream>
#include <thread>
using namespace std;
int g_count = 0;
 
void mythread1() {
	for (int i = 0; i < 1000000; i++) {
		g_count++;
	}
}
 
int main() {
	std::thread t1(mythread1);
	std::thread t2(mythread1);
	t1.join();
	t2.join();
	cout << "正常情况下结果应该是200 0000次，实际是" << g_count << endl;
}

在这里插入图片描述

使用mutex解决这个问题

#include <iostream>
#include <thread>
#include <mutex>
using namespace std;
int g_count = 0;
std::mutex mymutex;

void mythread1() {
	for (int i = 0; i < 1000000; i++) {
        //或用lock_guard<mutex> myguard(mymutex);
		std::unique_lock<std::mutex> u1(mymutex);
		g_count++;
	}
}
 
 
int main() {
	std::thread t1(mythread1);
	std::thread t2(mythread1);
	t1.join();
	t2.join();
	cout << "正常情况下结果应该是200 0000次，实际是" << g_count << endl;
}

在这里插入图片描述

3.2 基本的std::atomic用法范例

大家可以把原子操作理解成一种：不需要用到互斥量加锁（无锁）技术的多线程并发编程方式。

原子操作：在多线程中不会被打断的程序执行片段。

从效率上来说，原子操作要比互斥量的方式效率要高。

互斥量的加锁一般是针对一个代码段，而原子操作针对的一般都是一个变量。

原子操作，一般都是指==“不可分割的操作”==；也就是说这种操作状态要么是完成的，要么是没完成的，不可能出现半完成状态。

std::atomic来代表原子操作，是个类模板。其实std::atomic是用来封装某个类型的值的

需要添加#include <atomic>头文件

代码一：原子操作的简单示范

g_count这里要么是加完的值要么是没加的值；

#include <iostream>
#include <thread>
#include <atomic>
using namespace std;
std::atomic<int> g_count = 0; //封装了一个类型为int的 对象（值）

void mythread1() {
	for (int i = 0; i < 1000000; i++) {
		g_count++;
	}
}
 
int main() {
	std::thread t1(mythread1);
	std::thread t2(mythread1);
	t1.join();
	t2.join();
	cout << "正常情况下结果应该是200 0000次，实际是" << g_count << endl;
}

在这里插入图片描述

代码二：原子操作的示范二

#include <iostream>
#include <thread>
#include <atomic>
using namespace std;
std::atomic<bool> g_ifEnd = false; //封装了一个类型为bool的 对象（值）
 
void mythread() {
	std::chrono::milliseconds 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() {
	std::thread t1(mythread);
	std::thread t2(mythread);
	std::chrono::milliseconds dura(5000);
	std::this_thread::sleep_for(dura);
	g_ifEnd = true;
	t1.join();
	t2.join();
    cout << "程序执行完毕" << endl;
    return 0；
}

在这里插入图片描述

四、总结

1、原子操作一般用于计数或者统计（如累计发送多少个数据包，累计接收到了多少个数据包），多个线程一起统计，这种情况如果不使用原子操作会导致统计发生混乱。

2、写商业代码时，如果不确定结果的影响，最好自己先写一小段代码调试。或者不要使用。

毕加索来喽
关注
  • 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::future成员函数wait_for()
weixin_45983489的博客
03-11 5224
一、关于std::future成员函数wait_for()： 1.1 关于std::future_status： std::future_status是一个枚举类型，其值有三： // ENUM future_status enum class future_status { // names for timed wait function returns ready, timeout, deferred//延迟执行，当std::async()第一个参数为std::lanuch::de
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++ 多线程：std::future
iuices的博客
04-02 1万+
概念我们前面介绍的std::thread 是C++11中提供异步创建多线程的工具，只能是异步运行任务，却无法获取任务执行的结果，一般都是依靠全局对象，全局对象在多线程下是及其不安全的，为此标准库提供了std::future类模板来关联线程运行的函数和函数的返回结果，这种获取结果的方式是异步的。std::future 通常由某个 Provider 创建，你可以把 Provider 想象成一个异步任务的提供者，Provider 在某个线程中设置共享状态的值，与该共享状态相关联的 std::future 对象调用
C++标准库笔记-多线程-shared_future-future的补充扩展
黑山老妖的博客
05-16 1149
std::shared_future 在之前笔记C++11笔记-多线程-细说Future中，std::future提供了“处理并发运算之未来结果”的能力，但是只能处理一次结果，第二次调用get()会导致不可以预期的行为；因为调用get()后会将future的state状态置为无效状态； 在项目的不同场景中，也会有多次处理“并发运算之未来结果”的情况，特别是当多个其他线程都想处理这份结果时。所有C++标准库提供了std::shared_future，可以多次调用get()，产生相同结果或获得任务抛出的异常；
libstdc++.so.6.0.20 含GLIBCXX_3.4.15 - GLIBCXX_3.4.20
04-24
2. GLIBCXX_3.4.16：在此版本中，进一步增强了C++11的支持，比如添加了并发编程的std::future和std::promise，以及std::this_thread命名空间下的线程管理函数。这为开发者提供了更强大的多线程编程能力。 3. ...
C++11多线程编程.zip
09-24
C++11多线程编程future其他成员函数、shared_future、atomic C++11多线程编程std__atomic续谈、std__async深入谈 C++11多线程编程windows临界区、其他各种mutex互斥量 C++11多线程编程补充知识、线程池浅谈、数量谈...
C++11标准库比较全面.rar
07-21
10. **统一的构造函数初始化（Uniform Initialization）**： - 使用花括号`{}`进行对象初始化，无论是否是聚合类型，简化了初始化过程。 11. **新标准库组件**： - `std::array`：固定大小的数组，提供更安全的...
Effective.Modern.C++11.pdf
12-16
4. **智能指针make函数**：Meyers探讨了std::make_unique和std::make_shared等智能指针构造函数的用法，以及它们如何帮助避免资源管理错误。 5. **std::move、std::forward、右值引用(rvalue references)和通用引用...
一个用C++14实现的高并发http服务器.zip
最新发布
03-08
2. **异步编程**：C++14引入了`std::async`和`std::future`，用于实现异步任务和结果获取，避免阻塞主线程，提升并发性能。 3. **原子操作和互斥锁**：`<atomic>`库提供了原子操作，可以保证在多线程环境下数据的...
通俗讲解c++ future/shared_future
qq_38836770的博客
09-27 7514
目录future简介std::future对象只有在有效的(valid)情况下才有用(useful)查询future对象是否有效future的拷贝构造函数是被禁用的对future的处理四种方式获取future的状态future_status的三种状态： future简介 future 是一个用来获取异步任务的结果，其存在的意义 其实就是为了解决 std::thread 无法返回值的问题 future可以想象成一个来自未来的使者，定义它的时候，相当于某个预言家预言在未来的某一天会出现这个使者。 预言只有
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++11特性 future
SWELER的博客
12-12 376
简单讲一下c++11 的future用法。
c++多线程之shared_future
FairLikeSnow的博客
06-14 1166
shared_future也是一个类模板，get的时候是克隆（复制）出一个数据，而不是直接取出，所以能多次get()，下面是例子： void testPromise(std::promise<int> &mypromise, int x) { cout << "我是第一个线程,正在处理数据\n"; int nresult = 0; nresult = x + 10; nresult += 100; nresult -= 1; std::this_thread::s
C++11多线程：std::shared_future：也是个类模板，get()函数复制数据
weixin_55491446的博客
04-06 356
std::shared_future：也是个类模板，get()函数复制数据了解std::shared_future的用法。持续更新中…
C++11中std::future的使用
热门推荐
网络资源是无限的
01-30 2万+
C++11中的std::future是一个模板类。std::future提供了一种用于访问异步操作结果的机制。std::future所引用的共享状态不能与任何其它异步返回的对象共享(与std::shared_future相反)( std::future references shared state that is not shared with any other asynchronous re...
8 —— future其它成员函数、shared_future
baboon_chen
06-27 393
一 future其它成员函数 wait_for()   卡住当前流程，等待std::async()的异步任务运行一段时间，然后返回其状态std::future_status。如果std::async()的参数是std::launch::deferred（延迟执行），则不会卡住主流程。 std::future_status   枚举类型，表示异步任务的执行状态。   std::future_sta...
C++语法学习笔记五十一： future其他成员函数、shared_future、ato
哲学天空的博客
08-29 243
实例代码： // project4.cpp: 定义控制台应用程序的入口点。 // #include <iostream> #include <vector> #include <map> #include <string> #include <thread> #include <list> #include <mutex> #include <future> using namespace std; //in
C++日记——Day45：future其他成员函数、shared_future、atomic
weixin_38278993的博客
04-02 176
std::future 的成员函数 1、wait_for()：std::status::timeout \std::status::ready \std::status::deferred #include <thread> #include <iostream> #include <list> #include <map> #includ...
sn65dsi83的内核驱动static const struct drm_bridge_funcs sn65dsi83_funcs = { .attach = sn65dsi83_attach, .atomic_pre_enable = sn65dsi83_atomic_pre_enable, .atomic_enable = sn65dsi83_atomic_enable, .atomic_disable = sn65dsi83_atomic_disable, .atomic_post_disable = sn65dsi83_atomic_post_disable, .mode_valid = sn65dsi83_mode_valid, .atomic_duplicate_state = drm_atomic_helper_bridge_duplicate_state, .atomic_destroy_state = drm_atomic_helper_bridge_destroy_state, .atomic_reset = drm_atomic_helper_bridge_reset, .atomic_get_input_bus_fmts = sn65dsi83_atomic_get_input_bus_fmts, };这段的几个函数执行顺序是什么
06-02
这段代码定义了一个名为sn65dsi83_funcs的结构体，其中包含了多个函数指针，这些函数指针被用于驱动sn65dsi83的内核模块。这些函数的执行顺序...10. sn65dsi83_atomic_get_input_bus_fmts函数用于获取输入总线格式。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值