9.future其他成员函数，shared_future，atomic

最新推荐文章于 2024-03-23 23:02:38 发布
最新推荐文章于 2024-03-23 23:02:38 发布
阅读量153 收藏
点赞数
分类专栏： 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42341040/article/details/108705775
版权

1.future其他成员函数

std::future_status::timeout

等待1秒，因为线程入口函数要5秒，所以超时了（没有等到）

#include <iostream>
#include <vector>
#include <ctime>
#include<thread>
#include<mutex>
#include<future>
using namespace std;

int mythread() {//线程入口函数
	cout << "mythread() start, thread id = " << std::this_thread::get_id() << endl;

	std::chrono::microseconds dura(5000);//sleep 5s
	std::this_thread::sleep_for(dura);//休息一定时长

	cout << "mythread() end, thread id = " << std::this_thread::get_id() << endl;
	return 5;
}

int main()
{

	//一：std::async, std::future创建后台任务并返回值
	/*
		std::async是个函数模板，用来启动一个异步任务，启动一个异步任务之后，他返回一个std::future对象，std::future是个类模板
		什么叫“启动一个异步任务”：就是自动创建一个线程并开始执行对应的线程入口函数，他返回一个std::future对象，
			这个std::future对象里边就含有线程入口函数所返回的结果（线程返回的结果），我们可以通过调用future对象的成员函数get()来获取结果；
			future:将来的意思，有人也称呼std::future提供了一种访问异步操作结果的机制，就是说这个结果你可能不能马上得到，
			在线程执行完毕的时候，你就能拿到结果了。所以大家就这么理解：这个future(对象)里会保存一个值，在将来的某个时刻可以拿到

	*/
	//下列程序通过std::future对象的get()成员函数等待线程执行结束并返回结果
	//这个get()函数很牛，不拿到将来的返回值誓不罢休，不拿到值我就卡在这等待拿值
	cout << "main thread id = " << std::this_thread::get_id() << endl;
	std::future<int>result = std::async(mythread);//创建一个线程并开始执行，绑定关系
	cout << "continue....." << endl;
	
	//返回枚举类型
	//wait_for等待一段时间
	std::future_status status = result.wait_for(std::chrono::seconds(1));//等待1秒
	if (status == std::future_status::timeout) {//超时：我想等待你1秒，希望你返回，你没有返回，那么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;
		//到get这里才开始执行
		cout << result.get() << endl;
	}
	//cout << result.get() << endl;//卡在这里等待mythread()执行完毕，拿到结果,get()只能调用一次
	//result.wait();//等待线程返回，本身并不返回结果
	cout << "hello world" << endl;


	return 0;
}
/*
output:

	main thread id = 10012
	continue.....
	mythread() start, thread id = 4860
	超时，线程还没执行完毕
	hello world
	mythread() end, thread id = 4860


*/

std::future_status::ready

#include <iostream>
#include <vector>
#include <ctime>
#include<thread>
#include<mutex>
#include<future>
using namespace std;

int mythread() {//线程入口函数
	cout << "mythread() start, thread id = " << std::this_thread::get_id() << endl;

	std::chrono::microseconds dura(5000);//sleep 5s
	std::this_thread::sleep_for(dura);//休息一定时长

	cout << "mythread() end, thread id = " << std::this_thread::get_id() << endl;
	return 5;
}

int main()
{

	//一：std::async, std::future创建后台任务并返回值
	/*
		std::async是个函数模板，用来启动一个异步任务，启动一个异步任务之后，他返回一个std::future对象，std::future是个类模板
		什么叫“启动一个异步任务”：就是自动创建一个线程并开始执行对应的线程入口函数，他返回一个std::future对象，
			这个std::future对象里边就含有线程入口函数所返回的结果（线程返回的结果），我们可以通过调用future对象的成员函数get()来获取结果；
			future:将来的意思，有人也称呼std::future提供了一种访问异步操作结果的机制，就是说这个结果你可能不能马上得到，
			在线程执行完毕的时候，你就能拿到结果了。所以大家就这么理解：这个future(对象)里会保存一个值，在将来的某个时刻可以拿到

	*/
	//下列程序通过std::future对象的get()成员函数等待线程执行结束并返回结果
	//这个get()函数很牛，不拿到将来的返回值誓不罢休，不拿到值我就卡在这等待拿值
	cout << "main thread id = " << std::this_thread::get_id() << endl;
	std::future<int>result = std::async(mythread);//创建一个线程并开始执行，绑定关系
	cout << "continue....." << endl;
	
	//返回枚举类型
	//wait_for等待一段时间
	std::future_status status = result.wait_for(std::chrono::seconds(6));//等待6秒
	if (status == std::future_status::timeout) {//超时：我想等待你6秒，希望你返回，你没有返回，那么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;
		//到get这里才开始执行
		cout << result.get() << endl;
	}
	//cout << result.get() << endl;//卡在这里等待mythread()执行完毕，拿到结果,get()只能调用一次
	//result.wait();//等待线程返回，本身并不返回结果
	cout << "hello world" << endl;


	return 0;
}
/*

output:
	main thread id = 6776
	continue.....
	mythread() start, thread id = 2360
	mythread() end, thread id = 2360
	线程执行完毕,返回
	5
	hello world

*/

std::future_status::deferred

如果async的第一个参数被设置为std::launch::deferred，则wait_for返回的是std::future_status::deferred

#include <iostream>
#include <vector>
#include <ctime>
#include<thread>
#include<mutex>
#include<future>
using namespace std;

int mythread() {//线程入口函数
	cout << "mythread() start, thread id = " << std::this_thread::get_id() << endl;

	std::chrono::microseconds dura(5000);//sleep 5s
	std::this_thread::sleep_for(dura);//休息一定时长

	cout << "mythread() end, thread id = " << std::this_thread::get_id() << endl;
	return 5;
}

int main()
{

	//一：std::async, std::future创建后台任务并返回值
	/*
		std::async是个函数模板，用来启动一个异步任务，启动一个异步任务之后，他返回一个std::future对象，std::future是个类模板
		什么叫“启动一个异步任务”：就是自动创建一个线程并开始执行对应的线程入口函数，他返回一个std::future对象，
			这个std::future对象里边就含有线程入口函数所返回的结果（线程返回的结果），我们可以通过调用future对象的成员函数get()来获取结果；
			future:将来的意思，有人也称呼std::future提供了一种访问异步操作结果的机制，就是说这个结果你可能不能马上得到，
			在线程执行完毕的时候，你就能拿到结果了。所以大家就这么理解：这个future(对象)里会保存一个值，在将来的某个时刻可以拿到

	*/
	//下列程序通过std::future对象的get()成员函数等待线程执行结束并返回结果
	//这个get()函数很牛，不拿到将来的返回值誓不罢休，不拿到值我就卡在这等待拿值
	cout << "main thread id = " << std::this_thread::get_id() << endl;
	std::future<int>result = std::async(std::launch::deferred, mythread);//创建一个线程并开始执行，绑定关系
	cout << "continue....." << endl;
	
	//返回枚举类型
	//wait_for等待一段时间
	std::future_status status = result.wait_for(std::chrono::seconds(1));//等待1秒
	if (status == std::future_status::timeout) {//超时：我想等待你1秒，希望你返回，你没有返回，那么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;
		//到get这里才开始执行
		cout << result.get() << endl;
	}
	//cout << result.get() << endl;//卡在这里等待mythread()执行完毕，拿到结果,get()只能调用一次
	//result.wait();//等待线程返回，本身并不返回结果
	cout << "hello world" << endl;


	return 0;
}
/*
output:
没有创建子线程
	main thread id = 7920
	continue.....
	线程被延迟执行
	mythread() start, thread id = 7920
	mythread() end, thread id = 7920
	5
	hello world

*/

2.std::shared_future

#include <iostream>
#include <vector>
#include <ctime>
#include<thread>
#include<mutex>
#include<future>
using namespace std;

int mythread(int mypar) {//线程入口函数

	cout << mypar << endl;
	cout << "mythread() start, thread id = " << std::this_thread::get_id() << endl;

	std::chrono::microseconds dura(5000);//sleep 5s
	std::this_thread::sleep_for(dura);//休息一定时长

	return 5;
}
void mythread2(std::shared_future<int>& tmpf) {
	cout << "mthread2() start" << " threadid = " << std::this_thread::get_id() << endl;
	auto result = tmpf.get();//get值可以获取多次了
	result = tmpf.get();
	result = tmpf.get();
	result = tmpf.get();
	result = tmpf.get();
	cout << "mythread2 result = " << result << endl;
}
int main()
{
	/*

		因为future类成员函数get只能调用一次，万一多个线程函数都想得到get的值呢？ ==>  引出std::shared_future
		二.std::shared_future是个类模板
			get()函数复制数据

	*/
	cout << "main thread id = " << std::this_thread::get_id() << endl;
	std::packaged_task<int(int)>mypt(mythread);//我们把函数mythread通过packaged_task包装起来
	std::thread t1(std::ref(mypt), 1);//线程直接开始执行。第二个参数作为线程入口函数的参数。
	t1.join();//等待线程执行完毕

	std::future<int>result = mypt.get_future();//std::future对象里包含有线程入口函数的返回结果，这里result保存mythread返回的结果
	bool flag = result.valid();//true  是有效值
	std::shared_future<int>result_s(std::move(result));//执行完后result_s里有值了，而result空了
	flag = result.valid();//false  是无效值
	std::thread t2(mythread2, std::ref(result_s));
	t2.join();

	cout << "hello world" << endl;
	return 0;
}


/*
output:
	main thread id = 15268
	1
	mythread() start, thread id = 1868
	mthread2() start threadid = 16076
	mythread2 result = 5
	hello world


*/

3.原子操作std::atomic

3.1原子操作概念引出范例

#include <iostream>
#include <vector>
#include <ctime>
#include<thread>
#include<mutex>
#include<future>
using namespace std;

int mycount = 0;
void mythread() {
	for (int i = 0; i < 1000000; i++) {
		mycount++;
	}
}
int main()
{
	/*

		二.std::atomic
			互斥量：多线程编程中 保护共享数据：
			有两个线程，对一个变量进行操作，这个线程读，另一个线程往这个变量中写值 

	*/
	std::thread t1(mythread);
	std::thread t2(mythread);

	t1.join();
	t2.join();
	cout << "两个线程执行完毕，最终mycount的值 = " << mycount << endl;
	
	return 0;
}


/*
output:
	两个线程执行完毕，最终mycount的值 = 1076772
*/

结果并不是200万！

3.1.1加上mutex

正确执行了，但是效率很慢

#include <iostream>
#include <vector>
#include <ctime>
#include<thread>
#include<mutex>
#include<future>
using namespace std;

int mycount = 0;
std::mutex mymutex;
void mythread() {
	for (int i = 0; i < 1000000; i++) {
		mymutex.lock();//粒度小
		//unique_lock<mutex>my(mymutex);
		mycount++;
		mymutex.unlock();
	}
}
int main()
{
	/*

		二.std::atomic
			互斥量：多线程编程中 保护共享数据：
			有两个线程，对一个变量进行操作，这个线程读，另一个线程往这个变量中写值 

	*/

	std::thread t1(mythread);
	std::thread t2(mythread);

	t1.join();
	t2.join();
	cout << "两个线程执行完毕，最终mycount的值 = " << mycount << endl;

	
	return 0;
}
/*
output:
	两个线程执行完毕，最终mycount的值 = 2000000
*/

3.2 原子操作

1.大家可以把原子操作理解成一种：不需要用到互斥锁（无锁）技术的多线程并发编程方式
2.或者：原子操作是在多线程中不会被打断的程序执行片段
3.原子操作比互斥量效率高！
4.互斥量加锁一般是针对一个代码段，而原子操作针对一个变量，要么是完成的，要么是没完成的，不可能出现半完成状态

eg1

#include <iostream>
#include <vector>
#include <ctime>
#include<thread>
#include<mutex>
#include<future>
#include<atomic>
using namespace std;


std::atomic<int> mycount{ 0 };//封装了一个类型为int的对象（值）

void mythread() {
	for (int i = 0; i < 1000000; i++) {
		mycount++;	//原子操作不会被打断
	}
}
int main()
{
	/*

		二.std::atomic
			互斥量：多线程编程中 保护共享数据：
			有两个线程，对一个变量进行操作，这个线程读，另一个线程往这个变量中写值 
			
	*/
	int a;

	std::thread t1(mythread);
	std::thread t2(mythread);

	t1.join();
	t2.join();
	cout << "两个线程执行完毕，最终mycount的值 = " << mycount << endl;

	
	return 0;
}


/*
output:
	两个线程执行完毕，最终mycount的值 = 2000000
*/

eg2

#include <iostream>
#include <vector>
#include <ctime>
#include<thread>
#include<mutex>
#include<future>
#include<atomic>
using namespace std;


std::atomic<bool> isend{ false };//线程退出标记，这里是原子操作，防止读和写乱套

void mythread() {
	std::chrono::milliseconds dura(1000);
	while (!isend) {
		//系统没要求线程退出，所以本线程干自己想干的事
		cout << "thread id = " << std::this_thread::get_id() << "运行中" << endl;
		std::this_thread::sleep_for(dura);//sleep 1s
	}
	cout << "thread id = " << std::this_thread::get_id() << "运行结束..." << endl;
}
int main()
{
	/*

		二.std::atomic
			互斥量：多线程编程中 保护共享数据：
			有两个线程，对一个变量进行操作，这个线程读，另一个线程往这个变量中写值 
			
	*/
	int a;

	std::thread t1(mythread);
	std::thread t2(mythread);

	std::chrono::milliseconds dura(5000);
	std::this_thread::sleep_for(dura);
	isend = true;//对原子对象的写操作，让线程自行运行结束
	t1.join();
	t2.join();
	cout << "两个线程执行完毕 "  << endl;

	
	return 0;
}


/*
output:
	thread id = 9732运行中
	thread id = 14392运行中
	thread id = 14392运行中
	thread id = 9732运行中
	thread id = 14392运行中
	thread id = 9732运行中
	thread id = 14392运行中
	thread id = 9732运行中
	thread id = 14392运行中
	thread id = 9732运行中
	thread id = 14392运行结束...
	thread id = 9732运行结束...
	两个线程执行完毕
*/

3.3 心得

一般用于计数或者统计（累计发送出去了多少个数据包，累计接收到了多少个数据包）

哞哞哞咩咩咩
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python多线程及协程
m0_60027772的博客
08-08 787
当程序出现IO操作时，可以选择性的切换到其他任务上。
python 多线程和协程结合_Python 异步编程，看这门课就够了~
weixin_39833270的博客
11-21 267
我们常见的 Linux、Windows、Mac OS 操作系统，都是支持多进程的多核操作系统。所谓多进程，就是系统可以同时运行多个任务。例如我们的电脑上运行着 QQ、浏览器、音乐播放器、影音播放器等。在操作系统中，每个任务就是一个进程。每个进程至少做一件事，多数进程会做很多事，例如影音播放器，要播放画面，同时要播放声音。Python 多线程可以成倍提高程序的运行速度，而且在多数情况下都是...
python多线程多进程和协程总结
csdncjh的博客
10-15 3801
真正意义上的多线程是由CPU来控制的，例如如果一个CPU密集型的程序，用C语言写，运行在一个四核处理器上，采用多线程的话最多可以获得4倍的效率提升。但是用Python写的话，效率不会提高，甚至会变慢，因为Python中的多线程是由GIL控制的，GIL的全称是Global Interpreter Lock（全局解释器锁），Python最初的设计理念在于，为了解决多线程之间数据完整性和状态同步的问题，设计为在任意时刻只能由一个线程在解释器中运行。
Qt上位机HID和下位机stm32的USBHID通讯
weixin_41915375的博客
03-06 4573
Qt上位机和下位机stm32的USBHID通讯 1. 上位机Qt程序介绍 1.1、新建QT widget工程hidstm32生成工程文件后加入hidapi库文件 备注：调试时会弹出错误，因为系统缺少依赖文件msvcr100d.dll，把它放到windpws中SysWoW64或者System32文件夹中。 1.2工程中加入库 1.3调用hid_open(0x10c4, 0x82cd, NULL)...
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
- `std::atomic`提供原子操作，保证多线程环境下的数据一致性。 - `std::future`、`std::promise`支持异步计算和结果传递。 - `std::condition_variable`用于线程间的同步和通信。 8. **变长参数模板（Variadic ...
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>`库提供了原子操作，可以保证在多线程环境下数据的...
以16进制数的形式显示DX寄存器中的值
10-31
使用子程序结构实现下面的程序设计：以16进制数的形式显示DX寄存器中的值；
蓝桥杯-单片机基础8——上下位机的串口通信设置（附小蜜蜂课程代码）
最新发布
qq_43323677的博客
03-23 1793
一般来说，我们认为比赛用开发板就是下位机，我们的电脑就是上位机。由于采用异步串行通信方式，因此我们既可以从上位机向下位机发送数据，又可以在上位机接收下位机传来的数据，从未实现通信的效果。近年来的省体考串口通信不多，但往年偶尔考过。考题倾向于某种控制系统，即我们用电脑向单片机发送某种数据，单片机就产生对应的响应，并且单片机向电脑传回相关的数据，以此对串口编程进行考察。在了解串口通信的简单原理之后，可以将小蜜蜂老师的代码段背下来，比赛时直接使用。
给大家分享一篇 协程与多线程的合作
qq_41235053的博客
08-14 1869
概览 场景 实现 方法 总结 1. 场景 在写异步爬虫时，发现很多请求莫名其妙地超时。 原来是因为解析网页耗费了太多时间，使得部分请求超过预定时间。 根本上是因为，asyncio 的协程是非抢占式的。协程如果不主动交出控制权，就会一直执行下去。 假如一个协程占用了太多时间，那么其他协程就有可能超时挂掉。 下面我们用一个简短的程序实验一下。 import asyncio imp...
Python多线程开发--协程
冰点契约的博客
06-27 759
协程 协程(coroutine),又称为微线程,纤程。(协程是一种用户态的轻量级线程) 作用:在执行A 函数的时候,可以随时中断,去执行B 函数,然后中断继续执行A 函数(可以自动切换),注意这一过程并不是函数调用(没有调用语句),过程很像多线程,然而协程只有一个线程在执行 协作的标准 1.必须在只有一个单线程里实现并发 2.修改共享数据不需加锁 3.用户程序里自己保存多个控制流的上下文栈 4.一个协程遇到IO 操作自动切换到其它协程 协程创建方式1： 通过greenlet模块 from greenlet
线程池,协程
weixin_33892359的博客
09-26 119
1.线程池: 　　实例化线程池 ThreadPoolExcutor 起 5*cpu_count 　　异步提交任务 submit/map 　　阻塞直到任务结束 shutdown 　　获取子线程的返回值 result 　　回调函数 add_done_callback 起线程池推荐使用concurrent futrues 工作中提高效率,往往需要: 　　多进程 cpu_count 　...
python 进程 线程 协程
kk_12345z的博客
08-28 1307
1.进程 线程 协程 概念 a.进程 我们电脑的应用程序，都是进程，假设我们用的电脑是单核的，cpu同时只能执行一个进程。当程序处于I/O阻塞的时候，CPU如果和程序一起等待，那就太浪费了，cpu会去执行其他的程序，此时就涉及到切换，切换前要保存上一个程序运行的状态，才能恢复，所以就需要有个东西来记录这个东西，就可以引出进程的概念了。 ​ 进程就是一个程序在一个数据集上的一次动态执行过程。进程由程序，数据集，进程控制块三部分组成。程序用来描述进程哪些功能以及如何完成；数据集是程序执行过程中所使用的资源
[计算机操作系统] 进程、线程、线程池、协程的区别与联系
wangmj_hdu的博客
08-18 946
计算机操作系统之进程、线程、线程池、协程 1、进程、线程、协程 用一个表格来总结 进程 线程 协程 定义 进程就是进程实体，进程是资源分配和调度的基本单位。进程是程序的一次执行过程。进程是一个程序及其数据在处理机上顺序执行时所发生的活动。 线程是程序执行的基本单位。线程是轻量级的进程。每个进程都有唯一的主线程，主线程和线程是相互依存的关系，主线程结束进程也会结束 协程是线程内部调度的基本单位 切换者 操作系统 操作系统 用户 切换过程 用户态->内核态->用户态 用户态
python线程池模块_python并发编程之进程池，线程池，协程
weixin_39742568的博客
11-28 170
需要注意一下不能无限的开进程，不能无限的开线程最常用的就是开进程池，开线程池。其中回调函数非常重要回调函数其实可以作为一种编程思想，谁好了谁就去掉只要你用并发，就会有锁的问题，但是你不能一直去自己加锁吧那么我们就用QUEUE，这样还解决了自动加锁的问题由Queue延伸出的一个点也非常重要的概念。以后写程序也会用到这个思想。就是生产者与消费者问题一、Python标准模块--concurrent.fu...
线程池、协程
XST1520203418的博客
07-04 553
文章目录一、回顾多线程1.实现多线程的两个方法2.代码举例二、回顾爬虫数据解析主要方法三、线程池简单理解：使用线程池提取并储存一网址菜品信息四、协程1.time.sleep()的协程转变爬虫领域的简单协程模板2.requests.get()的协程转换爬取小说内容 一、回顾多线程 1.实现多线程的两个方法 ①创建线程 t = Thread(target=func)并启动t.start() ②创建一个继承Thread的类 2.代码举例 from threading import Thread class My(
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的结构体，其中包含了多...9. drm_atomic_helper_bridge_reset函数用于在原子模式下重置sn65dsi83的状态。 10. sn65dsi83_atomic_get_input_bus_fmts函数用于获取输入总线格式。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值