C++11并发与多线程笔记(10) future其他成员函数、shared_future、atomic

这篇具有很好参考价值的文章主要介绍了C++11并发与多线程笔记(10) future其他成员函数、shared_future、atomic。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

1、std::future 的成员函数

1.1 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
#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()执行完毕,拿到结果
	//等待6秒
    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){
		//如果async的第一个参数被设置为std::launch::deferred,则本条件成立
		cout<<"线程被延迟!!"<<endl;//mythread在主线程执行
		cout<<result.get()<,endl;
	}
	cout<<"I love China!"<<endl;
	return 0;
}

C++11并发与多线程笔记(10) future其他成员函数、shared_future、atomic,C++11并发与多线程笔记,c++,笔记

注意get()只能使用一次。get()函数的设计是一个移动语义,相当于将result中的值移动了,再次get就报告了异常。

2、std::shared_future:也是个类模板

  • std::future的 get() 成员函数是转移数据
  • std::shared_future 的 get()成员函数是复制数据
#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;
}

void mythread2(std::shared_future<int> &tmpf){//此时使用shared_future
	cout<<"mythread2() start"<<"threadid="<<std::this_thread::get_id()<<endl;
	auto result=tmpf.get();//可以get多次
	cout<<"mythread2 result="<<result<,endl;
}
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中的值是不是一个有效值
	//方法1
	std::shared_future<int> result_s(result.share()); //执行完毕后result_s里有值,而result里空了
	//方法2
	//std::shared_future<int> result_s(std::move(result));
	//方法3
    //通过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();
 	
 	std:: thread t2(mythread2,std::ref(result_s));
 	t2.join();//等待线程执行完毕
	cout << "good luck" << endl;
	return 0;
}

3、std::atomic原子操作

3.1 原子操作概念引出范例:

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

两个线程,对一个变量进行操作,一个线程这个变量的值,一个线程往这个变量中值。

(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++;
	}
	return;
}
 
int main() {
	std::thread t1(mythread1);
	std::thread t2(mythread1);
	t1.join();
	t2.join();
	cout << "正常情况下结果应该是200 0000次,实际是" << g_count << endl;
}

C++11并发与多线程笔记(10) future其他成员函数、shared_future、atomic,C++11并发与多线程笔记,c++,笔记
原因:一条C++语句会被拆成3、4条汇编语句,线程上下文切换就有可能打乱。

(2)如果使用互斥量 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++) {
		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;
}

C++11并发与多线程笔记(10) future其他成员函数、shared_future、atomic,C++11并发与多线程笔记,c++,笔记

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

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

原子操作:在多线程中不会被打断的程序执行片段
从效率上来说,原子操作要比互斥量的方式效率要

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

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

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

案例1:

#include <iostream>
#include <thread>
#include <atomic> //添加#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;
}

C++11并发与多线程笔记(10) future其他成员函数、shared_future、atomic,C++11并发与多线程笔记,c++,笔记
案例2(bool 案例):

#include <iostream>
#include <thread>
#include <atomic>
using namespace std;
std::atomic<bool> g_ifEnd = false; //封装了一个类型为bool的 对象(值)
 
void mythread() {
	std::chrono::milliseconds dura(1000);//1s
	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);//5s
	std::this_thread::sleep_for(dura);
	g_ifEnd = true;//对原子对象的写操性,让线程自行运行结束;
	t1.join();
	t2.join();
	cout << "程序执行完毕" << endl;
}

C++11并发与多线程笔记(10) future其他成员函数、shared_future、atomic,C++11并发与多线程笔记,c++,笔记
总结:

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

  2. 写商业代码时,如果不确定结果的影响,最好自己先写一小段代码调试。或者不要使用。文章来源地址https://www.toymoban.com/news/detail-660352.html

到了这里,关于C++11并发与多线程笔记(10) future其他成员函数、shared_future、atomic的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • C++11并发与多线程笔记(6) unique_lock(类模板)

    unique_lock 是一个类模板。 unique_lock 比 lock_guard 灵活很多 ( 多出来很多用法 ),效率差一点,内存占用多一些。 使用: unique_lockmutex myUniLock(myMutex); std::adopt_lock:标记作用,表示这个互斥量已经被lock()(方便记忆:已经被lock()收养了,不需要再次lock() ),即 不需要在构造函

    2024年02月12日
    浏览(41)
  • C++11并发与多线程笔记(7) 单例设计模式共享数据分析、解决,call_once

    程序灵活,维护起来可能方便,用设计模式理念写出来的代码很晦涩,但是别人接管、阅读代码都会很痛苦 老外应付特别大的项目时,把项目的开发经验、模块划分经验,总结整理成设计模式 中国零几年设计模式刚开始火时,总喜欢拿一个设计模式往上套,导致一个小小的

    2024年02月12日
    浏览(40)
  • 分布式集群与多线程高并发

      后台数据的处理语言有很多,Java 是对前端采集的数据的一种比较常见的开发语言。互联网移动客户端的用户量特别大,大量的数据处理需求应运而生。可移动嵌入式设备的表现形式   很多,如 PC 端,手机移动端,智能手表,Google  眼镜等。Server2client 的互联网开发模式比

    2024年02月08日
    浏览(45)
  • Python中的并发编程:多线程与多进程的比较【第124篇—多线程与多进程的比较】

    在Python编程领域中,处理并发任务是提高程序性能的关键之一。本文将探讨Python中两种常见的并发编程方式:多线程和多进程,并比较它们的优劣之处。通过代码实例和详细的解析,我们将深入了解这两种方法的适用场景和潜在问题。 多线程是一种轻量级的并发处理方式,适

    2024年03月14日
    浏览(94)
  • 再见了Future,图解JDK21虚拟线程的结构化并发

    Java为我们提供了许多启动线程和管理线程的方法。在本文中,我们将介绍一些在Java中进行并发编程的选项。我们将介绍 结构化并发 的概念,然后讨论 Java 21 中一组预览类——它使将任务拆分为子任务、收集结果并对其进行操作变得非常容易,而且不会不小心留下任何挂起的

    2024年02月05日
    浏览(56)
  • 【linux 多线程并发】多线程模型下的信号通信处理,与多进程处理的比较,属于相同进程的线程信号分发机制

    ​ 专栏内容 : 参天引擎内核架构 本专栏一起来聊聊参天引擎内核架构,以及如何实现多机的数据库节点的多读多写,与传统主备,MPP的区别,技术难点的分析,数据元数据同步,多主节点的情况下对故障容灾的支持。 手写数据库toadb 本专栏主要介绍如何从零开发,开发的

    2024年01月17日
    浏览(46)
  • 【Java基础教程】(四十二)多线程篇 · 上:多进程与多线程、并发与并行的关系,多线程的实现方式、线程流转状态、常用操作方法解析~

    理解进程与线程的区别; 掌握Java 中多线程的两种实现方式及区别; 掌握线程的基本操作方法; 进程是程序的一次动态执行过程,它经历了从代码加载、执行到执行完毕的一个完整过程,这个过程也是进程本身从产生、发展到最终消亡的过程 。多进程操作系统能同时运行多

    2024年02月16日
    浏览(45)
  • C++回调函数与多线程联动使用

    在业务场景中,会遇到这样的情况,当前类需要运行一个函数,这个函数会被使用多次或者耗时非常长,这时候我们希望把它放到子线程里面运行,主线程只需要知道它的运行状态即可(类似于进度条通知)。但我们又不希望更改该类任何地方(该类有可能是同事提供的,原

    2024年02月10日
    浏览(42)
  • 【并发编程】线程池多线程异步去分页调用其他服务接口获取海量数据

    前段时间在做一个数据同步工具,其中一个服务的任务是调用A服务的接口,将数据库中指定数据请求过来,交给kafka去判断哪些数据是需要新增,哪些数据是需要修改的。 刚开始的设计思路是,,我创建多个服务同时去请求A服务的接口,每个服务都请求到全量数据,由于这些

    2024年02月13日
    浏览(36)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包