C++多线程：async、future、packaged_task、promise、shared_future的学习与使用（九）

1、异步任务线程

  • 异步线程的概念：

    • 异步：就是非同步，同步就是必须一个一个的执行，异步可以两个事情一起干
    • 异步线程：异步线程就相当于把非关联的两件事分开找两个线程去执行，而分开的那个就是异步线程
    • 举例：例如登录信息，用户登录完毕主线程肯定是需要去及时响应用户的请求的，而系统设计的时候通常会保存用户的登录信息（日志）等等，如果处理这些任务的时间过长就可能无法及时响应用户的请求，而处理这些日志和响应用户是两个独立的事件，因此可以开启异步线程来处理日志，响应用户的操作继续由主线程向下执行，且无需等待异步线程的结果。

  • std::async、std::future

    • C++11线程库中提供了这std::async函数创建后台任务（异步线程）并且返回值
    • std::future类模板来支持获取异步线程std::async创建后台任务最后执行返回的值，
    • std::async是一个函数模板，用来启动一个异步任务，启动起来一个异步任务之后，它返回一个std::future对象，std::future是一个类模板
    • std::future类模板提供了一些函数，get可以获取返回值，wait系列获取不到

  • 启动异步任务：

    • 创建一个async线程并且开始执行对应的线程入口函数，它返回一个std::future对象
    • std::future对象里边就含有线程入口函数所返回的结果（线程返回的结果），我们可以通过调用future对象的成员函数get()来获取结果
    • std::future提供了一种访问异步操作结果的机制，就是说这个结果你可能没有办法马上拿到，但在不就的将来线程执行完毕的时候，就能够拿到结果了
    • 因此如果在std::future调用get之前就会出现两种情况：
      • 异步线程async已经计算完毕，那么std::future调用get直接获取结果
      • 异步线程async没有计算完毕，那么std::future调用get将会阻塞，等待async执行完毕并且返回。
1.1、std::async源码浅析
template<typename _Fn, typename... _Args>
inline future<__async_result_of<_Fn, _Args...>>
async(_Fn&& __fn, _Args&&... __args)
{return std::async(launch::async|launch::deferred,std::forward<_Fn>(__fn),std::forward<_Args>(__args)...);
}template<typename _Fn, typename... _Args>
future<__async_result_of<_Fn, _Args...>> async(launch __policy, _Fn&& __fn, _Args&&... __args){std::shared_ptr<__future_base::_State_base> __state;if ((__policy & launch::async) == launch::async){				// here__try{__state = __future_base::_S_make_async_state(std::thread::__make_invoker(std::forward<_Fn>(__fn),std::forward<_Args>(__args)...));}
#if __cpp_exceptionscatch(const system_error& __e) {if (__e.code() != errc::resource_unavailable_try_again|| (__policy & launch::deferred) != launch::deferred)throw;}
#endif}if (!__state){__state = __future_base::_S_make_deferred_state(std::thread::__make_invoker(std::forward<_Fn>(__fn),std::forward<_Args>(__args)...));}return future<__async_result_of<_Fn, _Args...>>(__state);
}

  • std::launch::async|std::launch::deferred：这两个是常量标记。

    • async表示立即创建异步线程
    • deferred表示推迟创建线程，推迟到future调用get或者wait时在创建

  • 默认情况下可以看到源码here处以async的默认形式创建线程，但是这只是Linux，并不知道其他编译器是什么样子！因此使用时根据自身的需求最好指定一下，防止编译器默认！

  • 而可以看到使用std::launch::deferred的并没有看到源码处有创建线程的代码，这里就被推迟了！

  • std::async就两个构造函数

    • 一个不指定launch方式的，只传入线程入口函数和入口函数参数的构造
    • 指定launch方式的构造，并且传入线程入口函数和入口函数参数的构造
1.2、future源码浅析
template<>
class future<void> : public __basic_future<void>{};template<typename _Res>
class future<_Res&> : public __basic_future<_Res&>{};template<typename _Res>
class future : public __basic_future<_Res>{friend class promise<_Res>;template<typename> friend class packaged_task;template<typename _Fn, typename... _Args>friend future<__async_result_of<_Fn, _Args...>> async(launch, _Fn&&, _Args&&...);typedef __basic_future<_Res> _Base_type;typedef typename _Base_type::__state_type __state_type;explicit future(const __state_type& __state) : _Base_type(__state) { }public:constexpr future() noexcept : _Base_type() { }/// Move constructorfuture(future&& __uf) noexcept : _Base_type(std::move(__uf)) { }// Disable copyingfuture(const future&) = delete;future& operator=(const future&) = delete;future& operator=(future&& __fut) noexcept {future(std::move(__fut))._M_swap(*this);return *this;}/// Retrieving the value_Res get(){typename _Base_type::_Reset __reset(*this);return std::move(this->_M_get_result()._M_value());}shared_future<_Res> share() noexcept;
};
  • future模板类提供了：void、Res、Res&引用三大类返回类型的处理，因此async可以void空返回、可以类型返回、可以引用返回
  • future最主要的就是get函数，get函数可以看到从一个方法中将值std::move移动出来
  • __basic_future是future的基类，里面提供了wait、wait_for、wait_unitl…函数，所以future可以调用到父类的这些方法
  • get这个函数只能调用一次，因为可以看到get函数中的实际操作是一个std::move，这个值移动之后就为空了。
2、async的使用
#include <iostream>
#include <thread>
#include <future>
#include <string>#ifndef INC_08_ASYNC_ASYNC_FUTURE_H
#define INC_08_ASYNC_ASYNC_FUTURE_Hclass AsyncFuture{
public:int class_thread_func(std::string msg){std::cout << msg << " 开始执行! thread_id =" << std::this_thread::get_id() << std::endl;std::chrono::milliseconds duration(5000);std::this_thread::sleep_for(duration);std::cout << msg << " 执行完毕! thread_id =" << std::this_thread::get_id() << std::endl;}
};int thread_func()
{std::cout << __func__ << " 开始执行! thread_id =" << std::this_thread::get_id() << std::endl;std::chrono::milliseconds duration(5000);std::this_thread::sleep_for(duration);std::cout << __func__ << " 执行完毕! thread_id =" << std::this_thread::get_id() << std::endl;return 5;
}#endif //INC_08_ASYNC_ASYNC_FUTURE_H\
2.1、普通成员函数
void async_test1()
{std::cout << "main thread_id = " << std::this_thread::get_id() << std::endl;std::future<int> async_result = std::async(std::launch::deferred, thread_func);std::cout << "continue......" <<  std::endl;std::cout << async_result.get() <<  std::endl;
}
/*由于get会阻塞等待，因此输出结果main thread_id = 139778198386496continue......这里阻塞等待async执行完毕thread_func 开始执行! thread_id =139778198386496thread_func 执行完毕! thread_id =1397781983864965
*/
2.2、类成员函数
void async_test2()
{std::string msg = "class_thread_func";std::cout << "main thread_id = " << std::this_thread::get_id() << std::endl;AsyncFuture asyncFuture;std::future<int> async_result = std::async(&AsyncFuture::class_thread_func, &asyncFuture, msg);std::cout << "continue......" <<  std::endl;std::cout << async_result.get() <<  std::endl;
}
/*由于get会阻塞等待，因此会阻塞main thread_id = 139783108294464这里阻塞等待async执行完毕continue......class_thread_func 开始执行! thread_id =139783090120448class_thread_func 执行完毕! thread_id =1397830901204483
*/
2.3、std::launch::deffered
void async_test3()
{std::cout << "main thread_id = " << std::this_thread::get_id() << std::endl;std::future<int> async_result = std::async(std::launch::deferred, thread_func);std::cout << "continue......" <<  std::endl;std::cout << async_result.get() <<  std::endl;
}
/*由于deffered是延迟创建，因此主线程在执行完之后调用get会导致两个线程串行，最后子线程不会new出来， 由主线程执行！main thread_id = 140214074877760continue......thread_func 开始执行! thread_id =140214074877760thread_func 执行完毕! thread_id =1402140748777605
*/void async_test4()
{std::cout << "main thread_id = " << std::this_thread::get_id() << std::endl;std::future<int> async_result = std::async(std::launch::deferred, thread_func);std::cout << "continue......" <<  std::endl;
}
/*没有调用get，不进行执行。但是可能在析构的时候会调用get或者wait执行，这个需要看编译器的情况来定，上面没有看到析构main thread_id = 139630206793536continue......*/
3、std::packaged_task类模板的使用

  • std::packaged_task是一个类模板，打包任务，把任务都装起来，

  • 它的模板参数是各种可调用对象，方便将来作为线程入口函数来调用

  • 写法很抽象，大概就是可以把一个线程进行打包起来，需要用的是可以以各种方式进行调用和返回一些东西， C++真是一门玄学

#include <iostream>
#include <thread>
#include <future>
#include <vector>
#include <string>int thread_func1(int t)
{std::cout << __func__ << " 开始执行! thread_id =" << std::this_thread::get_id() << std::endl;std::chrono::milliseconds duration(t);std::this_thread::sleep_for(duration);std::cout << __func__ << " 执行完毕! thread_id =" << std::this_thread::get_id() << std::endl;return t / 1000;
}void packaged_task_test()
{std::vector<std::packaged_task<int(int)>> container;std::cout << "main thread_id = " << std::this_thread::get_id() << std::endl;std::packaged_task<int(int)> my_packaged_task1(thread_func1);std::packaged_task<int(int)> my_packaged_task2([](int t){std::cout << __func__ << " 开始执行! thread_id =" << std::this_thread::get_id() << std::endl;std::chrono::milliseconds duration(t);std::this_thread::sleep_for(duration);std::cout << __func__ << " 执行完毕! thread_id =" << std::this_thread::get_id() << std::endl;return t / 1000;});container.emplace_back(std::move(my_packaged_task1));container.emplace_back(std::move(my_packaged_task2));int t = 1000;for(auto it = container.begin();it != container.end();it++){std::packaged_task<int(int)> my_packaged_task = std::move(*it);my_packaged_task(t);t += 2000;std::future<int> result = my_packaged_task.get_future();std::cout << result.get() << std::endl;}
}
  • 这一串代码就是把一个自定义函数和lambda函数都以packaged_task的格式打包，然后放到一个容器里
  • 最后需要的时候从容器里取出来，执行并且获取它们各自的返回值
4、promise类模板的使用
  • promise的作用主要是可以在一个线程中计算的结果可以通过它传入到另外一个线程中去
  • 当线程中存在大量的数据需要返回时，不仅可以通过线程入口函数的返回值带回，可以通过promise类模板进行带回
  • 基于这一点，其实在多个线程中进行数据通信或者需要协同等可以使用promise进行数据传递
  • 例如下面的例子：
    • get_result_thread_func线程入口函数依赖calculate_thread_func函数计算的结果
    • 在主线程中可以将calculate_thread_func进行异步创建，并且传入promise的引用
    • calculate_thread_func计算完毕将值塞入到promise中，结束线程
    • 主线程在创建一个get_result_thread_func线程，然后将上面的计算结果的get_future传入到该函数中
    • 在该函数中获取值，此时如果calculate_thread_func计算完毕就直接返回值，如果没有计算完毕就继续等待！
      • 为什么可以实现，其实很好理解，因为get_result_thread_func传入了calculate_thread_func的get_future类模板对象
      • 通过future类模板对象可以获取到线程的执行权、自然就可以获得这个传入的值。
#include <iostream>
#include <thread>
#include <future>
#include <vector>
#include <string>void calculate_thread_func(std::promise<int> &prom, int t)
{std::cout << __func__ << " 开始执行! thread_id =" << std::this_thread::get_id() << std::endl;std::chrono::milliseconds duration(1000);std::this_thread::sleep_for(duration);t += 1;t *= 10;std::cout << "calculate_thread_func()::t = " << t << std::endl;std::cout << __func__ << " 执行完毕! thread_id =" << std::this_thread::get_id() << std::endl;prom.set_value(t);
}void get_result_thread_func(std::future<int> &result)
{int calculate = result.get();std::cout << __func__ << " 开始执行! thread_id =" << std::this_thread::get_id() << std::endl;std::cout << "get_result_thread_func()::calculate result = " << calculate << std::endl;std::cout << __func__ << " 执行完毕! thread_id =" << std::this_thread::get_id() << std::endl;
}void test_promise()
{std::promise<int> prom;std::async(std::launch::async, calculate_thread_func, std::ref(prom), 365);std::future<int> calculate_result = prom.get_future();std::future<void> final_result = std::async(std::launch::async, get_result_thread_func, std::ref(calculate_result));final_result.get();
}
/*
calculate_thread_func 开始执行! thread_id =139767452948224
calculate_thread_func()::t = 3660
calculate_thread_func 执行完毕! thread_id =139767452948224
get_result_thread_func 开始执行! thread_id =139767452948224
get_result_thread_func()::calculate result = 3660
get_result_thread_func 执行完毕! thread_id =139767452948224
*/
6、future模板函数补充

  • future模板类其主要的方法就是get，并且这个get不能重复获取，其原因在之前的源码浅析中看过，get里面是对值的std::move，因此不能重复get获取线程的返回值。

  • 此外future模板类提供了除get外的一些其他函数例如wait_for、wait_until、vaild这些函数

    • wait_for：等待线程执行到指定的时间长度
    • wait_until：等待线程执行到一个固定的时间点
    • valid：判断是否可以get取值，可以为true，否则唯false

  • 如果等待的时间内线程会出现三种情况：

    • ready：在规定的时间内等到了线程的执行，future_status的状态为ready

    • timeout：在规定的时间内线程没有执行或者没有执行完毕，future_status的状态为timeout

    • deferred：线程创建时采用延迟创建，规定的时间内不会执行，那么future_status的状态为deferred

#include <iostream>
#include <string>
#include <thread>
#include <future>int thread_func(int t)
{std::cout << __func__ << " 开始执行! thread_id =" << std::this_thread::get_id() << std::endl;std::chrono::seconds duration(t);std::this_thread::sleep_for(duration);std::cout << __func__ << " 执行完毕! thread_id =" << std::this_thread::get_id() << std::endl;return 5;
}void future_func_test1()
{std::cout << "main thread_id = " << std::this_thread::get_id() << std::endl;
//    std::future<int> async_result = std::async(std::launch::async, thread_func, 1);				// ready
//    std::future<int> async_result = std::async(std::launch::async, thread_func, 3);				// timeoutstd::future<int> async_result = std::async(std::launch::deferred, thread_func, 1);			  // deferredstd::cout << "continue......" <<  std::endl;std::future_status status = async_result.wait_for(std::chrono::seconds(2));if(status == std::future_status::ready){std::cout << "线程已经执行完毕了!" << std::endl;std::cout << "thread_func return value = " << async_result.get() << std::endl;}else if(status == std::future_status::timeout){std::cout << "线程已经超时了！" << std::endl;  }else if(status == std::future_status::deferred){std::cout << "线程被延迟创建了！" << std::endl;std::cout << async_result.get() << std::endl;}
}
6.1、shared_future类模板

  • shared_future类模板和future类模板几乎没有区别，唯一的区别就是get()函数的返回值是否可以重复获取。

  • 如果线程A的值需要被线程B和线程C的都需要使用，那么就需要重复获取这个值了。

  • 为了解决future无法重复获取的这个烦恼，C++11提供了shared_future类，其实就是可以重复get获取线程返回值的future

  • 由于返回的是一个引用因此多次获取都是同一个地址，一处修改这个值将会导致这个值的更改

6.1.1、future和shared_future的get函数源码对比
// future
_Res get(){typename _Base_type::_Reset __reset(*this);return std::move(this->_M_get_result()._M_value());
}// shared_future
const _Res&  get() const { return this->_M_get_result()._M_value(); }
6.1.2、简单使用
int thread_func(int t)
{std::cout << __func__ << " 开始执行! thread_id =" << std::this_thread::get_id() << std::endl;std::chrono::seconds duration(t);std::this_thread::sleep_for(duration);std::cout << __func__ << " 执行完毕! thread_id =" << std::this_thread::get_id() << std::endl;return 5;
}void shared_future_func_test2()
{std::cout << "main thread_id = " << std::this_thread::get_id() << std::endl;std::shared_future<int> async_result = std::async(std::launch::deferred, thread_func, 1);std::cout << "continue......" <<  std::endl;for(int i = 0;i < 3;i++) {if (async_result.valid()) {int a = async_result.get();std::cout << "a = " << a << ", &a = " << &a << std::endl;}}
}
/*
输出
main thread_id = 140671767070528
continue......
thread_func 开始执行! thread_id =140671767070528
thread_func 执行完毕! thread_id =140671767070528
a = 5, &a = 0x7ffc0452ec00
a = 5, &a = 0x7ffc0452ec00
a = 5, &a = 0x7ffc0452ec00
*/
7、总结

  • 学习这些东西都是为了将其灵活使用，能够把它们融入到我们自己的实际开发当中

  • 能够灵活的写出稳定的多线程并发程序

  • 便于我们认识新的东西，通过学习它们可以通过阅读一些高手写的代码从而实现快速的代码积累和开拓眼界

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/794170.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

06-kafka配置

06-kafka配置

生产者配置 NAMEDESCRIPTIONTYPEDEFAULTVALID VALUESIMPORTANCEbootstrap.servershost/port列表&#xff0c;用于初始化建立和Kafka集群的连接。列表格式为host1:port1,host2:port2,…&#xff0c;无需添加所有的集群地址&#xff0c;kafka会根据提供的地址发现其他的地址&…
阅读更多...
golang设计模式图解——模板方法模式

golang设计模式图解——模板方法模式

设计模式 GoF提出的设计模式有23个&#xff0c;包括&#xff1a; &#xff08;1&#xff09;创建型(Creational)模式&#xff1a;如何创建对象&#xff1b; &#xff08;2&#xff09;结构型(Structural )模式&#xff1a;如何实现类或对象的组合&#xff1b; &#xff08;3&a…
阅读更多...
FastAPI Web框架教程 第13章 WebSocket

FastAPI Web框架教程 第13章 WebSocket

13-1 WebSocket是什么 WebSocket简介&#xff1a; WebSocket是一种在单个TCP连接上进行全双工通信的协议。 WebSocket使得客户端和服务器之间的数据交换变得更加简单&#xff0c;允许服务端主动向客户端推送数据。 在WebSocket API中&#xff0c;浏览器和服务器只需要完成一…
阅读更多...
【JavaSE】反射

【JavaSE】反射

Java代码的生命周期 Java代码在计算机中经历的阶段&#xff1a;Source源代码阶段、Class类对象阶段、RunTime运行时阶段。 Source源代码阶段: 这个阶段是由程序员编写生成源代码,再由Javac编译器生成class文件。 Class类对象阶段&#xff1a;由类加载器将class文件加载到JVM内…
阅读更多...
【网站项目】少儿编程管理系统

【网站项目】少儿编程管理系统

&#x1f64a;作者简介&#xff1a;拥有多年开发工作经验&#xff0c;分享技术代码帮助学生学习&#xff0c;独立完成自己的项目或者毕业设计。 代码可以私聊博主获取。&#x1f339;赠送计算机毕业设计600个选题excel文件&#xff0c;帮助大学选题。赠送开题报告模板&#xff…
阅读更多...
备战蓝桥杯---多路归并与归并排序刷题

备战蓝桥杯---多路归并与归并排序刷题

话不多说&#xff0c;直接看题 1. 我们考虑一行一行合并&#xff0c;一共m次&#xff0c;我们合并两个并取前n小&#xff0c;那么我们怎么取&#xff1f; 我们采用分组的思想&#xff1a; 我们选第一列的min,然后把后面那个再纳入考虑&#xff0c;用优先队列实现即可。 下面…
阅读更多...
chatGPT4无法登录

chatGPT4无法登录

遇到问题&#xff1a;chatgpt网站上点击登录&#xff08;log in),网站就会跳转并显示&#xff1a;unable to connect 解决方法&#xff1a;不要用亚洲节点&#xff0c;亚洲节点被全面封禁&#xff0c;在全局代理中可以换成美国的节点
阅读更多...
synchronized到底锁住的是谁？

synchronized到底锁住的是谁？

我们使用synchronized关键字是用来实现线程同步的&#xff0c;当多个线程同时去争抢同一个资源的时候在资源上边加一个synchronized关键字&#xff0c;能够使得线程排队去完成操作。 synchronized到底锁定的是什么资源&#xff1f; 修饰方法非静态方法 &#xff0c;锁定的是方…
阅读更多...
《UE5_C++多人TPS完整教程》学习笔记30 ——《P31 摄像机和弹簧臂（Camera And Spring Arm）》

《UE5_C++多人TPS完整教程》学习笔记30 ——《P31 摄像机和弹簧臂（Camera And Spring Arm）》

本文为B站系列教学视频 《UE5_C多人TPS完整教程》 —— 《P31 摄像机和弹簧臂&#xff08;Camera And Spring Arm&#xff09;》 的学习笔记&#xff0c;该系列教学视频为 Udemy 课程 《Unreal Engine 5 C Multiplayer Shooter》 的中文字幕翻译版&#xff0c;UP主&#xff08;…
阅读更多...
使用git 和 github协作开发

使用git 和 github协作开发

文章目录 github浏览器汉化插件github新建仓库git安装以及ssh配置团队创建及基本命令的使用创建团队基本命令 分支管理快速切换远程仓库地址 如何使用git && github进行协作开发&#xff0c;包括git常见基础命令 github浏览器汉化插件 在刚开始使用github的时候&#…
阅读更多...
ubuntu安装docker，并搭建vulfocus靶场

ubuntu安装docker，并搭建vulfocus靶场

ubuntu安装docker&#xff0c;并搭建vulfocus靶场 docker是一个容器管理的软件&#xff0c;容器背后其实就是一个进程&#xff1b;类似于一个集装箱。 docker的官方下载地址&#xff1a;Install Docker Engine on Ubuntu | Docker Documentation&#xff08;可以根据自己需要的…
阅读更多...
BL200耦合器数据采集模块

BL200耦合器数据采集模块

BL200耦合器数据采集模块是一个数据采集和控制系统&#xff0c;基于强大的32 位ARM926EJ-S™ 微处理器设计&#xff0c;采用Linux操作系统&#xff0c;支持Modbus TCP协议&#xff0c;可以快速接入现场PLC、MES、Ignition和SCADA以及ERP系统&#xff0c;同时也能快速连接到AWS云…
阅读更多...
【文献分享】机器学习 + 分子动力学 + 第一性原理 + 热力学性质 + 微观结构

【文献分享】机器学习 + 分子动力学 + 第一性原理 + 热力学性质 + 微观结构

分享一篇关于机器学习 分子动力学 第一性原理 热学性质&#xff08;密度、比热容、导热率和粘度&#xff09; 微观结构的文章。 感谢论文的原作者&#xff01; 关键词&#xff1a; 1. Deep potential 2. Machine learning 3. Molecular dynamics 4. Microscopic structu…
阅读更多...
Linux｜ Awk 中“next”命令奇用

Linux｜ Awk 中“next”命令奇用

简介 本文[1]介绍了在Linux中使用Awk的next命令来跳过剩余的模式和表达式&#xff0c;读取下一行输入的方法。 next命令 在 Awk 系列教程中&#xff0c;本文要讲解如何使用 next 命令。这个命令能让 Awk 跳过所有你已经设置的其他模式和表达式&#xff0c;直接读取下一行数据。…
阅读更多...
【无标题】【Android】Android中Intent的用法总结

【无标题】【Android】Android中Intent的用法总结

2.显示地图: Java代码 Uri uri Uri.parse(“geo:38.899533,-77.036476”); Intent it new Intent(Intent.Action_VIEW,uri); startActivity(it); 3.从google搜索内容 Java代码 Intent intent new Intent(); intent.setAction(Intent.ACTION_WEB_SEARCH); intent.pu…
阅读更多...
【C++进阶】【STL】set和map的讲解及模拟实现

【C++进阶】【STL】set和map的讲解及模拟实现

&#x1fa90;&#x1fa90;&#x1fa90;欢迎来到程序员餐厅&#x1f4ab;&#x1f4ab;&#x1f4ab; 主厨&#xff1a;邪王真眼 主厨的主页&#xff1a;Chef‘s blog 所属专栏&#xff1a;c大冒险 总有光环在陨落&#xff0c;总有新星在闪烁 一、 关联式容器 在初阶阶…
阅读更多...
github中git clone需要username和password问题

github中git clone需要username和password问题

username&#xff1a;一般指你的昵称 password&#xff1a;一般指Creating a fine-grained personal access token 这个的获取办法如下&#xff08;注意&#xff0c;在11步的时候&#xff0c;记得打开你仓库对应的一些access 权限&#xff09;&#xff1a; Note: Fine-graine…
阅读更多...
动态规划刷题（算法竞赛、蓝桥杯）--线段（线性DP）

动态规划刷题（算法竞赛、蓝桥杯）--线段（线性DP）

1、题目链接&#xff1a;P3842 [TJOI2007] 线段 - 洛谷 | 计算机科学教育新生态 (luogu.com.cn) #include <bits/stdc.h> using namespace std; const int N20010; int a[N][2],f[N][2]; //a[i][0]表示l[i],a[i][1]表示r[i] int dis(int a,int b){return abs(a-b); } int…
阅读更多...
前端pdf.js将pdf转为图片，尤其适合电子发票打印

前端pdf.js将pdf转为图片，尤其适合电子发票打印

写这个的原因就是打电子发票不方便&#xff0c;这个代码是纯js不需要后端服务直接将两张电子发票的pdf转为两张图片渲染到一张A4纸上面&#xff08;完全不浪费&#xff0c;发票也不会变大&#xff09;&#xff0c;自动完成打印分页&#xff0c;点击打印即可。亲测可用所有电子发…
阅读更多...
Java中的网络编程（一）

Java中的网络编程（一）

一、网络编程概述 什么是计算机网络把不同区域的计算机&#xff08;广义&#xff09;通过通信设备和线路连接&#xff0c;可以实现数据的传输和共享的系统。实现不同计算机之间的练习&#xff0c;必须有介质连接。网络编程是干什么的聊天-->聊天软件 QQjava语言是支持网络间…
阅读更多...
最新文章

Copyright @ 2022~2023