8.async，future, packaged_task, promise

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

C++11 多线程std:: async与std::thread的区别

一.std::async, std::future创建后台任务并返回值

普通函数形式

#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;
	int def = 0;
	cout << result.get() << endl;//卡在这里等待mythread()执行完毕，拿到结果,get()只能调用一次
	//result.wait();//等待线程返回，本身并不返回结果
	cout << "hello world" << endl;


	return 0;
}
/*
output:

main thread id = 15060
continue.....
mythread() start, thread id = 11996
mythread() end, thread id = 11996
5
hello world

*/

类成员函数形式

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


class A {
public:
	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);//休息一定时长

		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()函数很牛，不拿到将来的返回值誓不罢休，不拿到值我就卡在这等待拿值
	A a;
	int tmppar = 12;
	cout << "main thread id = " << std::this_thread::get_id() << endl;
	std::future<int>result = std::async(&A::mythread,&a,tmppar);//创建一个线程并开始执行，绑定关系
	cout << "continue....." << endl;
	int def = 0;
	cout << result.get() << endl;//卡在这里等待mythread()执行完毕，拿到结果,get()只能调用一次
	//result.wait();//等待线程返回，本身并不返回结果
	cout << "hello world" << endl;


	return 0;
}


/*
output:
	main thread id = 13876
	continue.....
	12
	mythread() start, thread id = 2488
	mythread() end, thread id = 2488
	5
	hello world

*/

std::launch::deferred

我们通过额外向std::async()传递一个参数，该参数的类型是std::launch类型（枚举类型），来达到一些特殊的目的；
a)std::launch::defered表示线程入口函数调用被延迟到std::future的wait()或者get()函数调用时才执行；
那么，如果wait()或者get()没有调用，线程会执行吗？没执行，实际上线程根本没创建！
std::launch::deferred延迟调用，并且没有创建新线程，是在主线程中调用的线程入口函数！

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


class A {
public:
	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);//休息一定时长

		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()函数很牛，不拿到将来的返回值誓不罢休，不拿到值我就卡在这等待拿值
	A a;
	int tmppar = 12;
	cout << "main thread id = " << std::this_thread::get_id() << endl;
	std::future<int>result = std::async(std::launch::deferred,&A::mythread,&a,tmppar);//创建一个线程并开始执行，绑定关系
	cout << "continue....." << endl;
	int def = 0;
	cout << result.get() << endl;//卡在这里等待mythread()执行完毕，拿到结果,get()只能调用一次
	//result.wait();//等待线程返回，本身并不返回结果
	cout << "hello world" << endl;


	return 0;
}


/*
output:
    发现主线程和子线程id号都一样，根本没创建子线程！

	main thread id = 13216
	continue.....
	12
	mythread() start, thread id = 13216
	mythread() end, thread id = 13216
	5
	hello world

*/

这里注释掉cout << result.get() << endl看看

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


class A {
public:
	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);//休息一定时长

		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()函数很牛，不拿到将来的返回值誓不罢休，不拿到值我就卡在这等待拿值
	A a;
	int tmppar = 12;
	cout << "main thread id = " << std::this_thread::get_id() << endl;
	std::future<int>result = std::async(std::launch::deferred,&A::mythread,&a,tmppar);//创建一个线程并开始执行，绑定关系
	cout << "continue....." << endl;
	int def = 0;
	//cout << result.get() << endl;//卡在这里等待mythread()执行完毕，拿到结果,get()只能调用一次
	//result.wait();//等待线程返回，本身并不返回结果
	cout << "hello world" << endl;


	return 0;
}


/*
output:
    发现主线程和子线程id号都一样，根本没创建子线程！

	main thread id = 9776
	continue.....
	hello world

*/

std::launch::async

在调用async函数的时候就开始创建线程

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


class A {
public:
	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);//休息一定时长

		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()函数很牛，不拿到将来的返回值誓不罢休，不拿到值我就卡在这等待拿值
	A a;
	int tmppar = 12;
	cout << "main thread id = " << std::this_thread::get_id() << endl;
	std::future<int>result = std::async(std::launch::async,&A::mythread,&a,tmppar);//创建一个线程并开始执行，绑定关系
	cout << "continue....." << endl;
	int def = 0;
	cout << result.get() << endl;//卡在这里等待mythread()执行完毕，拿到结果,get()只能调用一次
	//result.wait();//等待线程返回，本身并不返回结果
	cout << "hello world" << endl;


	return 0;
}


/*
output:
    main thread id = 14644
	continue.....
	12
	mythread() start, thread id = 10496
	mythread() end, thread id = 10496
	5
	hello world


*/

std::launch::acync|std::launch::deferred

两种情况都有可能，默认就是这种（不手动传递任何一种）

二.std::packaged_task

#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);//休息一定时长

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

int main()
{
	/*
		二.std::packaged_task:打包任务，把任务包装起来
		是个类模板，他的模板参数是各种可调用对象；通过std::packaged_task来把各种可调用对象包装起来，方便将来作为线程入口函数来调用
		
	*/
	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返回的结果
	cout << result.get() << endl;
	cout << "hello world" << endl;
	return 0;
}


/*
output:
   main thread id = 2084
	1
	mythread() start, thread id = 11244
	mythread() end, thread id = 11244
	5
	hello world



*/

用lambda表达式作为线程入口函数

#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);//休息一定时长

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

int main()
{
	/*
		二.std::packaged_task:打包任务，把任务包装起来
		是个类模板，他的模板参数是各种可调用对象；通过std::packaged_task来把各种可调用对象包装起来，方便将来作为线程入口函数来调用
		
	*/
	cout << "main thread id = " << std::this_thread::get_id() << endl;
	std::packaged_task<int(int)>mypt([](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);//休息一定时长

			cout << "mythread() end, thread id = " << std::this_thread::get_id() << endl;
			return 5;
		
		});//我们把函数mythread通过packaged_task包装起来
	std::thread t1(std::ref(mypt),1);//线程直接开始执行。第二个参数作为线程入口函数的参数。
	t1.join();//等待线程执行完毕
	std::future<int>result = mypt.get_future();//std::future对象里包含有线程入口函数的返回结果，这里result保存mythread返回的结果
	cout << result.get() << endl;
	cout << "hello world" << endl;
	return 0;
}


/*
output:
   main thread id = 2084
	1
	mythread() start, thread id = 11244
	mythread() end, thread id = 11244
	5
	hello world

*/

用packaged_task包装起来的可调用对象还可以直接调用，所以从这个角度看，packaged_task对象也是一个可调用对象

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

int main()
{
	cout << "main thread id = " << std::this_thread::get_id() << endl;
	std::packaged_task<int(int)>mypt([](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);//休息一定时长

			cout << "mythread() end, thread id = " << std::this_thread::get_id() << endl;
			return 5;
		
		});//我们把函数mythread通过packaged_task包装起来
	//std::thread t1(std::ref(mypt),1);//线程直接开始执行。第二个参数作为线程入口函数的参数。
	mypt(1);//直接调用，没有创建新线程
	//t1.join();//等待线程执行完毕
	std::future<int>result = mypt.get_future();//std::future对象里包含有线程入口函数的返回结果，这里result保存mythread返回的结果
	cout << result.get() << endl;
	cout << "hello world" << endl;
	return 0;
}


/*
output:

相当于函数调用，没有创建线程
	main thread id = 14176
	1
	mythread() start, thread id = 14176
	mythread() end, thread id = 14176
	5
	hello world


*/


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

vector<std::packaged_task<int(int)>>mytasks;//容器
int main()
{
	/*
		二.std::packaged_task:打包任务，把任务包装起来
		是个类模板，他的模板参数是各种可调用对象；通过std::packaged_task来把各种可调用对象包装起来，方便将来作为线程入口函数来调用
		
	*/
	cout << "main thread id = " << std::this_thread::get_id() << endl;
	std::packaged_task<int(int)>mypt([](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);//休息一定时长

			cout << "mythread() end, thread id = " << std::this_thread::get_id() << endl;
			return 5;
		
		});//我们把函数mythread通过packaged_task包装起来

	mytasks.push_back(std::move(mypt));//容器,移动语义，入进去之后mypt就为空！

	//.....
	std::packaged_task<int(int)>mypt2;
	vector<std::packaged_task<int(int)>>::iterator iter = mytasks.begin();
	mypt2 = std::move(*iter);//移动语义

	mytasks.erase(iter);//删除第一个元素，迭代已经失效，所以后续代码不可以继续使用iter
	mypt2(123);

	
	std::future<int>result = mypt2.get_future();//std::future对象里包含有线程入口函数的返回结果，这里result保存mythread返回的结果
	cout << result.get() << endl;
	cout << "hello world" << endl;
	return 0;
}


/*
output:

相当于函数调用，没有创建线程
	main thread id = 9932
	123
	mythread() start, thread id = 9932
	mythread() end, thread id = 9932
	5
	hello world
*/

三.std::promise

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

void mythread(std::promise<int>& temp,int calc) {//大家注意第一个参数
	//一系列复杂运算
	//做其他运算，比如花了整整5秒
	std::chrono::milliseconds dura(5000);
	std::this_thread::sleep_for(dura);
	//计算完成了
	int result = calc;//保存结果
	temp.set_value(result);//结果我保存到了temp这个对象中；

}

void mythread2(std::future<int>&temp) {
	auto result = temp.get();
	cout << "mythread2 result = " << result << endl;
}
int main()
{
	/*
		三.std::promise:
		是个类模板，我们能够在某个线程中给他赋值，然后我们可以在其他线程中把这个值取出来用
		总结：通过promise保存一个值，在将来某个时刻我们通过把一个future绑定到这个promise上来得到这个绑定值
		
	*/

	std::promise<int>myprom;//声明一个std::promise对象，保存的值类型为int
	std::thread t1(mythread, std::ref(myprom), 180);
	t1.join();

	//获取结果值
	std::future<int>fu1 = myprom.get_future();//promise和future绑定，用于获取线程返回值

	std::thread t2(mythread2, std::ref(fu1));
	t2.join();

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


/*
output:

mythread2 result = 180
hello world



*/
哞哞哞咩咩咩
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++11的future和promise、parkged_task使用
08-19
C++11的future和promise、packaged_task使用 C++11中引入了future、promise和packaged_task三个概念，用于实现异步编程和并发编程。这三个概念都是用于处理异步操作的结果，以下是它们的详细介绍： 一、future ...
C++11之std::future以及async函数、promise类和packaged_task类结构图
03-18
C++11之std::future以及async函数、promise类和packaged_task类结构图
C++ future/promise/thread/async/packaged_task入门
Fireplusplus的博客
01-11 912
std::promise、future、thread、async、packaged_task这些到底是个啥？
C++多线程：async、future、packaged_task、promise、shared_future的学习与使用（九）
weixin_43808717的博客
04-01 1100
学习这些东西都是为了将其灵活使用，能够把它们融入到我们自己的实际开发当中能够灵活的写出稳定的多线程并发程序便于我们认识新的东西，通过学习它们可以通过阅读一些高手写的代码从而实现快速的代码积累和开拓眼界。
async、future、packaged_task、promise
weixin_42136255的博客
05-24 204
一、std::async、std::future 创建后台任务并返回值 希望线程返回一个结果； std::async是一个函数模板，用来启动一个异步任务，启动起来一个异步任务之后，返回一个std::future对象。 什么叫做启动一个异步任务？就是自动创建一个线程并开始执行对应的线程入口函数，它返回一个std::future对象。这个std::future对象里边就含有线程入口函数所返回的结果(线程返回的结果);我们可以调用future对象的成员函数get()来获取结果。 future 将来的意思，
C++的future，promise，packaged_task
Lasuerte的博客
01-15 456
1. future与async配合使用 个人理解就是用future获取该线程函数的返回值，并可以知道该线程函数何时执行完； #include <iostream> #include <string> #include <thread> #include <future> unsigned long long CalcuBigNum(unsig...
C++11并发与多线程笔记（9） async、future、packaged_task、promise
Lakers
08-19 1499
C++11并发与多线程笔记（9） async、future、packaged_task、promise
cpp11_Promise_Future.docx
06-15
C++11 Promise 和 Future C++11 提供了一个基于任务的并行程序设计的方法，称为 Promise 和 Future。Promise 代表了异步操作的结果，Future 代表了对异步操作的结果的等待。它们之间的关系是 Promise 提供一个值，...
stdfure.zip
05-29
- 使用`std::promise`和`std::packaged_task`：你可以创建一个`std::promise`，设置其关联的`std::future`，然后使用`std::promise`的`get_future()`方法获取`std::future`。`std::packaged_task`是一个包装器，它...
05创建公务卡扣减明细表_CASH_USE_MINUSAMT_DETAIL_20240708-刘君.sql
最新发布
07-19
05创建公务卡扣减明细表_CASH_USE_MINUSAMT_DETAIL_20240708-刘君.sql
【BP回归预测】龙格库塔算法优化BP神经网络RUN-BP光伏数据预测（多输入单输出）【含Matlab源码 5171期】.zip
07-19
CSDN海神之光上传的全部代码均可运行，亲测可用，直接换数据就行，适合小白； 1、代码压缩包内容 主函数：Main .m； 数据； 调用函数：其他m文件；无需运行 运行结果效果图； 2、代码运行版本 Matlab 2019b；若运行有误，根据提示修改；若不会，可私信博主； 3、运行操作步骤 步骤一：将所有文件放到Matlab的当前文件夹中； 步骤二：双击打开除Main.m的其他m文件； 步骤三：点击运行，等程序运行完得到结果； 4、仿真咨询 如需其他服务，可私信博主或扫描博主博客文章底部QQ名片； 4.1 CSDN博客或资源的完整代码提供 4.2 期刊或参考文献复现 4.3 Matlab程序定制 4.4 科研合作 智能优化算法优化BP神经网络分类预测系列程序定制或科研合作方向： 4.4.1 遗传算法GA/蚁群算法ACO优化BP 4.4.2 粒子群算法PSO/蛙跳算法SFLA优化BP 4.4.3 灰狼算法GWO/狼群算法WPA优化BP 4.4.4 鲸鱼算法WOA/麻雀算法SSA优化BP 4.4.5 萤火虫算法FA/差分算法DE优化BP 4.4.6 其他优化算法优化BP
在UCA上结合DOA估计算法和自适应波束形成matlab代码.rar
07-19
1.版本：matlab2014/2019a/2021a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 5.作者介绍：某大厂资深算法工程师，从事Matlab算法仿真工作10年；擅长智能优化算法、神经网络预测、信号处理、元胞自动机等多种领域的算法仿真实验，更多仿真源码、数据集定制私信+。 替换数据可以直接使用，注释清楚，适合新手
【信号分解】基于海鸥优化算法SOA-CEEMDAN实现信号去躁附matlab代码.rar
07-19
1.版本：matlab2014/2019a/2021a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 5.作者介绍：某大厂资深算法工程师，从事Matlab算法仿真工作10年；擅长智能优化算法、神经网络预测、信号处理、元胞自动机等多种领域的算法仿真实验，更多仿真源码、数据集定制私信+。 替换数据可以直接使用，注释清楚，适合新手
毕业设计javajspKTV包房管理系统(ssh)-qkrp源码含文档
07-19
毕业设计javajspKTV包房管理系统(ssh)-qkrp源码含文档 后台是ssh框架，页面是jsp，数据库mysql，jdk1.8，开发工具用ecplise、myecplise、sts、idea都可以 采用全新的计算机网络和管理系统，将成为提高KTV管理效率，改善服务水准的重要手段之一。所以城市KTV包房信息管理系统是KTV经营不可缺少的现代工具。系统的主要功能包括：会员管理、类别管理、包房管理、预订管理。 包含：源码、数据库脚本、论文、环境工具包、相同框架项目的安装教程（在说明文档中）
基于Springboot的图书管理系统论文
07-19
传统信息管理主要依赖管理人员的手工登记与管理。然而，近年来信息技术的快速进步促使许多陈旧的信息管理方式得以更新。特别是图书信息，因其管理内容复杂且数量庞大，手工处理方式已难以满足广大用户的需求，于是图书管理系统应运而生。 本图书管理系统设有管理员和用户两种权限。管理员负责管理用户基本信息、公告信息及图书信息，并能与用户进行交流等。用户则可以查看图书信息、公告以及管理员的回复等。 该系统采用WEB应用程序开发中流行的小程序结构模式，使用空间占用小但功能全面的MySQL数据库进行数据存储，并运用了JSP技术进行开发。该图书管理系统有效解决了传统手工操作中的诸多问题，如数据查询耗时长、管理步骤繁琐等。总体而言，该图书管理系统性能稳定、功能完备，且具有较高的性价比。
自监督学习：YOLO模型性能提升的新前沿
07-19
YOLO（You Only Look Once）是一种流行的实时对象检测系统，最初由 Joseph Redmon 等人在 2015 年提出。它的核心思想是将对象检测任务视为一个回归问题，直接从图像像素到边界框坐标和类别概率的映射。YOLO 以其快速和高效而闻名，特别适合需要实时处理的应用场景。 以下是 YOLO 的一些关键特点： 1. **单次检测**：YOLO 模型在单次前向传播中同时预测多个对象的边界框和类别概率，不需要多次扫描图像。 2. **速度快**：YOLO 非常快速，能够在视频帧率下进行实时检测，适合移动设备和嵌入式系统。 3. **端到端训练**：YOLO 模型可以从原始图像直接训练到最终的检测结果，无需复杂的后处理步骤。 4. **易于集成**：YOLO 模型结构简单，易于与其他视觉任务（如图像分割、关键点检测等）结合使用。 5. **多尺度预测**：YOLO 可以通过多尺度预测来检测不同大小的对象，提高了检测的准确性。 YOLO 已经发展出多个版本，包括 YOLOv1、YOLOv2（也称为 YOLO9000）、YOLOv3、YOLOv4 和 YOLOv5 等。
【信号分解】基于粒子群优化算法PSO-CEEMDAN实现信号去躁附matlab代码.rar
07-19
1.版本：matlab2014/2019a/2021a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 5.作者介绍：某大厂资深算法工程师，从事Matlab算法仿真工作10年；擅长智能优化算法、神经网络预测、信号处理、元胞自动机等多种领域的算法仿真实验，更多仿真源码、数据集定制私信+。 替换数据可以直接使用，注释清楚，适合新手
读书笔记：LeanCloud 知识库 用户使用常见问题.zip
07-19
读书笔记：LeanCloud 知识库 用户使用常见问题
高分项目-基于SpringBoot框架实现的自习室预订系统（包含全套源码 + 数据库sql + 论文）.zip
07-19
高分项目-基于SpringBoot框架实现的自习室预订系统（包含全套源码 + 数据库sql + 论文）
client.loop.create_task( 如何使用
06-08
`client.loop.create_task()` 是一个 `asyncio` 函数，用于在事件循环中创建一个新的协程任务。它的用法如下所示： ```python async def my_coroutine(): # 协程任务的实现代码 # 创建一个事件循环实例 loop = ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值