多线程(进程池代码)

线程池介绍

那究竟什么是线程池呢？

线程池是一种线程使用模式.

线程过多会带来调度开销，进而影响缓存局部性和整体性能.
而线程池维护着多个线程，等待着监督管理者分配可并发执行的任务.
这避免了在处理短时间任务时创建与销毁线程的代价.
线程池不仅能够保证内核的充分利用，还能防止过分调度.
前面我们介绍过生产者消费者模型，线程池其实看作是它的一个变型
它把任务队列和消费者(线程)进行了封装，统称为server
用户不需要再关心线程创建的问题，只需要构建好任务，把它直接送往server里面即可，server会帮我们解决对应的任务
在这里插入图片描述
具体的应用场景有哪些呢？

    1. 需要大量的线程来完成任务，且完成任务的时间比较短.
      WEB服务器完成网页请求这样的任务，使用线程池技术是非常合适的.因为单个任务小，而任务数量巨大，你可以想象一个热门网站的点击次数.
    1. 对性能要求苛刻的应用，比如要求服务器迅速响应客户请求。
    1. 接受突发性的大量请求，但不至于使服务器因此产生大量线程的应用。突发性大量客户请求，在没有线程池情况下，将产生大量线程，虽然理论上大部分操作系统线程数目最大值不是问题，短时间内产生大量线程可能使内存到达极限，从而出现错误

第一个版本(基本框架搭建)

了解基本概念后，我们就可以具体实现相应的代码
本质上就是创建一个类
不过该类里面会自动封装相应的锁，条件变量，以及对应创建销毁线程的方法
一旦实例化，就有相应的线程为我们服务，用户不需要再考虑线程创建的问题，而只需要传任务即可
具体代码如下：

    1. 任务队列我们依旧用queue进行实现，并且不对任务的上限做约束
    1. 线程数目我们先设定为5个，如果有需求，再进行对应的调整即可
  1 #pragma once2 #include <iostream>3 #include <vector>4 #include <queue>5 #include "Task.hpp"6 #include <pthread.h>7 8 const static int N = 5;  //默认线程数量9 template <class T>10 class ThreadPool11 {12 public:13   ThreadPool(int num = N):_num(num),_threads(num)14   {15     pthread_mutex_init(&_mutex,nullptr);16     pthread_cond_init(&_cond,nullptr);17   }18   ~ThreadPool()19   {20     pthread_mutex_destroy(&_mutex);21     pthread_cond_destroy(&_cond);22   }23   void LockQueue()24   {25     pthread_mutex_lock(&_mutex); //给任务队列上锁26   }27   void UnlockQueue()28   {29     pthread_mutex_unlock(&_mutex); //给任务队列解锁30   }                                                                                                                                                                 31   void ThreadWait()32   {33     pthread_cond_wait(&_cond,&_mutex);  //没有任务，线程自动进入等待34   }35   void ThreadWakeUp()36   {37     pthread_cond_signal(&_cond);  //唤醒任务队列里面的线程38   }39   //判断任务队列是否为空                                                                                                                                            40   bool Isempty()41   {42     return _tasks.empty();43   }44   T popTask()45   {46     T t = _tasks.front();47     _tasks.pop();48     return t;49   }50   void PushTask(const T&t)51   {52     LockQueue();  //给任务队列加锁53     _tasks.push(t); //任务入列54     ThreadWakeUp(); //唤醒线程进行工作55     UnlockQueue(); //任务队列解锁56   }57   static void* ThreadRoutine(void* args)58   {59      //每个线程自己挂接，这样自动销毁60      pthread_detach(pthread_self());61      //将传进啦的this指针，转成我们的对象，这样即可访问里面的方法和成员变量62      ThreadPool<Task>* tp = static_cast<ThreadPool<Task> *>(args);63      while (true)64      {65        tp->LockQueue();  //每个线程访问任务队列时，都必须先加锁66        //任务队列不为空67        while(tp->Isempty())68        {69           tp->ThreadWait();  //假如没有任务，则等待                                                                                                                 70        }71        //有任务，取出对应的任务72        T t = tp->popTask();73        //归还锁，让其它线程也能够拿到74        tp->UnlockQueue();75        t();  //执行任务76        std::cout << "ThreadRoutine done:" << t.formatRes() << std::endl;77      }78   }79   //创建对应的线程80   void start()81   { 82     //创建对应的线程83     for(int i = 0;i < _num;i++)84     {85        pthread_create(&_threads[i],nullptr,ThreadRoutine,(void*)this);86     }87   }88 private:89   std::vector<pthread_t> _threads; //线程编号向量90   int _num;   //线程数量91 92   std::queue<T> _tasks;  //任务数量93   pthread_mutex_t _mutex; //锁94   pthread_cond_t _cond;   //条件变量95 };

第二个版本(封装自己的线程)

在第一个版本中，我们采用的是原生线程库里面的线程进行的封装
但我们还可以进一步进行改造，用我们之前自己封装的线程，来实现线程池.

//自己封装的线程
#include <iostream>
#include <stdlib.h>
#include <pthread.h>
#include <cstring>
#include <string>
class Thread{
public:typedef enum{NEW = 0,RUNNING,EXITED}ThreadStatus;typedef void* (*func_t)(void*);
public:Thread(int num,func_t func,void* args):_tid(0),_status(NEW),_func(func),_args(args){//名字由于还要接收用户给的编号，因此在构造函数内进行初始化char buffer[128];snprintf(buffer,sizeof(buffer),"thread-%d",num);_name = buffer;}~Thread(){}//返回线程的状态int status()  {return _status;}//返回线程的名字std::string name() {return _name;}//返回线程的id//只有线程在运行的时候，才会有对应的线程idpthread_t GetTid(){if (_status == RUNNING){return _tid;}else{return 0;}}//pthread_create函数默认第三个参数是void *(*start_routine) (void *)//而类成员函数具有默认参数this指针，直接传并不匹配，所以我们用static修饰，使其变成类成员函数//但是会有新的问题——无法访问类内成员，也就无法调用_funcstatic void * ThreadRun(void* args){Thread* ts = (Thread*)args;  //此时就获取到我们对象的指针// _func(args);  //无法回调相应的方法(成员变量无法直接被访问)(*ts)(); //传this指针进来，用仿函数回调_funcreturn nullptr;}void operator()() //仿函数{//假如传进来的线程函数不为空，则调用相应的函数if(_func != nullptr)  _func(_args);}//线程运行void Run(){//线程创建的参数有四个int n = pthread_create(&_tid,nullptr,ThreadRun,this);if(n != 0)  exit(0);_status = RUNNING;}//线程等待void Join(){int n = pthread_join(_tid,nullptr);if (n != 0){std::cerr << "main thread join error :" << _name << std::endl;return;}_status = EXITED;}
private:pthread_t _tid;    //线程idstd::string _name; //线程的名字func_t _func;       //未来要回调的函数void*_args;ThreadStatus _status; //目前该线程的状态
};

//V2版本
#pragma once
#include <iostream>
#include <vector>
#include <queue>
#include "Task.hpp"
#include <pthread.h>const static int N = 5;  //默认线程数量
template <class T>
class ThreadPool
{
public:ThreadPool(int num = N):_num(num),_threads(num){pthread_mutex_init(&_mutex,nullptr);pthread_cond_init(&_cond,nullptr);}~ThreadPool(){pthread_mutex_destroy(&_mutex);pthread_cond_destroy(&_cond);}void LockQueue(){pthread_mutex_lock(&_mutex); //给任务队列上锁}void UnlockQueue(){pthread_mutex_unlock(&_mutex); //给任务队列解锁}void ThreadWait(){pthread_cond_wait(&_cond,&_mutex);  //没有任务，线程自动进入等待}void ThreadWakeUp(){pthread_cond_signal(&_cond);  //唤醒任务队列里面的线程}//判断任务队列是否为空bool Isempty(){return _tasks.empty();}T popTask(){T t = _tasks.front();_tasks.pop();return t;}void PushTask(const T&t){LockQueue();  //给任务队列加锁_tasks.push(t); //任务入列ThreadWakeUp(); //唤醒线程进行工作UnlockQueue(); //任务队列解锁}static void* ThreadRoutine(void* args){//每个线程自己挂接，这样自动销毁pthread_detach(pthread_self());//将传进啦的this指针，转成我们的对象，这样即可访问里面的方法和成员变量ThreadPool<Task>* tp = static_cast<ThreadPool<Task> *>(args);while (true){tp->LockQueue();  //每个线程访问任务队列时，都必须先加锁//任务队列不为空while(tp->Isempty()){tp->ThreadWait();  //假如没有任务，则等待}//有任务，取出对应的任务T t = tp->popTask();//归还锁，让其它线程也能够拿到tp->UnlockQueue();t();  //执行任务std::cout << "ThreadRoutine done:" << t.formatRes() << std::endl;}}//创建对应的线程void start(){ //创建对应的线程for(int i = 0;i < _num;i++){pthread_create(&_threads[i],nullptr,ThreadRoutine,(void*)this);}}
private:std::vector<pthread_t> _threads; //线程编号向量int _num;   //线程数量std::queue<T> _tasks;  //任务数量pthread_mutex_t _mutex; //锁pthread_cond_t _cond;   //条件变量
};

第三个版本(封装自己的锁)

在第二个版本中，我们用自己封装的线程，来实现线程池.
再进一步改造，我们还可以用我们自己封装的锁，来进一步进行封装.

//自己封装的锁
#pragma once#include <iostream>
#include <pthread.h>class Mutex
{
public:Mutex(pthread_mutex_t* mutex):pmutex(mutex){}~Mutex(){}void Lock(){pthread_mutex_lock(pmutex);}void Unlock(){pthread_mutex_unlock(pmutex);}
private:pthread_mutex_t* pmutex;
};class LockGuard
{
public:LockGuard(pthread_mutex_t* mutex):_mutex(mutex){//在创建的时候，就自动上锁_mutex.Lock();}~LockGuard(){//销毁的时候，自动解锁_mutex.Unlock();}private:Mutex _mutex;
};

我们自己实现的锁，会在创建时，自动上锁；出了作用域后，自动进行解锁
因此我们原来线程池代码可以进一步进行优化
给任务队列进行上锁，解锁的成员函数，都可以直接删除
假如要上锁，只需要创建对应LockGuard对象即可，然后把临界区的代码用中括号全部括起来

#pragma once
#include <iostream>
#include <vector>
#include <queue>
#include "Task.hpp"
#include <pthread.h>
#include "Thread.hpp"
#include "mymutex.hpp"const static int N = 5;  //默认线程数量
template <class T>
class ThreadPool
{
public:ThreadPool(int num = N):_num(num){pthread_mutex_init(&_mutex,nullptr);pthread_cond_init(&_cond,nullptr);}~ThreadPool(){for(auto &t:_threads){t.Join();}pthread_mutex_destroy(&_mutex);pthread_cond_destroy(&_cond);}pthread_mutex_t* Getlock(){return &_mutex;}void ThreadWait(){pthread_cond_wait(&_cond,&_mutex);  //没有任务，线程自动进入等待}void ThreadWakeUp(){pthread_cond_signal(&_cond);  //唤醒任务队列里面的线程}//判断任务队列是否为空bool Isempty(){return _tasks.empty();}T popTask(){T t = _tasks.front();_tasks.pop();return t;}void PushTask(const T&t){LockGuard lockguard(&_mutex);_tasks.push(t); //任务入列ThreadWakeUp(); //唤醒线程进行工作}static void* ThreadRoutine(void* args){//将传进啦的this指针，转成我们的对象，这样即可访问里面的方法和成员变量ThreadPool<Task>* tp = static_cast<ThreadPool<Task> *>(args);while (true){T t;//任务队列不为空{LockGuard lockguard(tp->Getlock());while(tp->Isempty()){tp->ThreadWait();  //假如没有任务，则等待}//有任务，取出对应的任务t = tp->popTask();}t();  //执行任务std::cout <<  " Routine done:" << t.formatRes() << std::endl;}}//创建对应的线程void Init(){for(int i = 0;i < _num;i++){_threads.push_back(Thread(i,ThreadRoutine,(void*)this));} }void start(){for (auto &t:_threads){ t.Run();   //调用自定义线程里面的Run函数，创建相应的线程}}void Check(){for(auto &t:_threads){std::cout << t.name()<< " is Running..." <<std::endl;}}
private:std::vector<Thread> _threads; //线程编号向量int _num;   //线程数量std::queue<T> _tasks;  //任务数量pthread_mutex_t _mutex; //锁pthread_cond_t _cond;   //条件变量
};

我们可以用我们实现的线程池，完成加减乘除的任务
首先实现一个Task类，该类会用传入其中的x,y,运算符创建对象
调用对应的仿函数，即可完成对应的四则运算任务

#pragma once
#include <iostream>
#include <string>class Task
{
public://无参构造Task(){}Task(int x,int y,char op):_x(x),_y(y),_op(op),_result(0),_exitflag(0){}~Task(){}void operator()(){switch(_op){case '+':{_result = _x + _y;break;}case '-':{_result = _x - _y;break;}case '*':{_result = _x * _y;break;}case '/':{if(_y == 0)_exitflag = -1;else_result = _x / _y;break;}case '%':{  if (_y == 0)_exitflag = -2;else_result = _x % _y;break;}default:break;}}std::string formatArgs(){return std::to_string(_x) + _op + std::to_string(_y) + "="; }std::string formatRes(){return std::to_string(_result) + "(" + std::to_string(_exitflag) + ")";}
private:int _x;int _y;char _op; //运算符int _result; //运算的结果int _exitflag; //退出成功与否
};

主函数传参时，把对应构建好的Task类对象传入即可，剩下的工作，线程池会自动帮我们创建好对应的线程，执行并显示我们的任务

#include <iostream>
#include "Task.hpp"
#include <unistd.h>
#include <memory>
//#include "ThreadPool_V1.hpp"
//#include "ThreadPool_V2.hpp"
#include "ThreadPool_V3.hpp"
int main()
{ThreadPool<Task>* tp = new ThreadPool<Task>();tp->Init();tp->start();  //线程池启动tp->Check();  //看线程是否启动成功while(true){int x,y;char op;std::cout << "Please enter x:";std::cin >> x;std::cout << "Please enter y:";std::cin >> y;std::cout << "Please enter op(+-*/%):";std::cin >> op;Task t(x,y,op);tp->PushTask(t);  //将任务传入线程池中即可}return 0;
}

结果显示：
在这里插入图片描述

第四个版本(线程安全版本)

IT行业这么火, 涌入的人很多. 俗话说林子大了啥鸟都有. 大佬和菜鸡们两极分化的越来越严重. 为了让菜鸡们不太拖大佬的后腿,
于是大佬们针对一些经典的常见的场景, 给定了一些对应的解决方案, 这个就是 设计模式
其中单例模式就是设计模式中的一种
所谓的单例模式就是指，有一个特殊类，有且只有用它来创建一个对象
为什么要设计这种模式呢？
拿我们线程池来举例，线程池这个对象，大多数时候，我们并不需要创建多个，假如任务很多，我们只要相应调节线程池里面的线程数目即可，假如创建多个线程池对象，这样其实效率并不高.
单例对象的最终目的就是为了提高效率

那具体如何设计这个特殊类呢？(懒汉模式)
1.构造函数私有化，拷贝，赋值函数删除(这样外面的用户也就不能再创建对象了)
2.类成员变量中加入类指针，并用static进行修饰
3.在类内提供相应接口函数，每次用户调用该接口时，用类指针创建对象，但是假如类指针不为空，也就是已经创建了一个对象，则直接返回该对象的指针，不会再创建新的对象

具体改造后的代码如下：

#pragma once
#include <iostream>
#include <vector>
#include <queue>
#include "Task.hpp"
#include <pthread.h>
#include "Thread.hpp"
#include "mymutex.hpp"const static int N = 5;  //默认线程数量
template <class T>
class ThreadPool
{
private:ThreadPool(int num = N):_num(num){pthread_mutex_init(&_mutex,nullptr);pthread_cond_init(&_cond,nullptr);}ThreadPool(const ThreadPool<T>& tp) = delete;  //删除构造函数void operator=(const ThreadPool<T>& tp) = delete; //删除赋值函数public:static ThreadPool<T>* GetInstance(){if(nullptr == instance)//提高效率 {LockGuard lockguard(&instance_lock); if(nullptr == instance) //保证有且只有一个线程可以创建对象{instance = new ThreadPool<T>();instance->Init();instance->start();}}return instance;}~ThreadPool(){for(auto &t:_threads){t.Join();}pthread_mutex_destroy(&_mutex);pthread_cond_destroy(&_cond);}pthread_mutex_t* Getlock(){return &_mutex;}void ThreadWait(){pthread_cond_wait(&_cond,&_mutex);  //没有任务，线程自动进入等待}void ThreadWakeUp(){pthread_cond_signal(&_cond);  //唤醒任务队列里面的线程}//判断任务队列是否为空bool Isempty(){return _tasks.empty();}T popTask(){T t = _tasks.front();_tasks.pop();return t;}void PushTask(const T&t){LockGuard lockguard(&_mutex);_tasks.push(t); //任务入列ThreadWakeUp(); //唤醒线程进行工作}static void* ThreadRoutine(void* args){//将传进啦的this指针，转成我们的对象，这样即可访问里面的方法和成员变量ThreadPool<Task>* tp = static_cast<ThreadPool<Task> *>(args);while (true){T t;//任务队列不为空{LockGuard lockguard(tp->Getlock());while(tp->Isempty()){tp->ThreadWait();  //假如没有任务，则等待}//有任务，取出对应的任务t = tp->popTask();}t();  //执行任务std::cout <<  " Routine done:" << t.formatRes() << std::endl;}}//创建对应的线程void Init(){for(int i = 0;i < _num;i++){_threads.push_back(Thread(i,ThreadRoutine,(void*)this));} }void start(){for (auto &t:_threads){ t.Run();   //调用自定义线程里面的Run函数，创建相应的线程}}void Check(){for(auto &t:_threads){std::cout << t.name()<< " is Running..." <<std::endl;}}
private:std::vector<Thread> _threads; //线程编号向量int _num;   //线程数量std::queue<T> _tasks;  //任务数量pthread_mutex_t _mutex; //锁pthread_cond_t _cond;   //条件变量static ThreadPool<T>* instance; //类对象指针static pthread_mutex_t instance_lock; //类对象锁
};//对对象指针进行初始化
template <class T>
ThreadPool<T>* ThreadPool<T>::instance = nullptr;//对类对象锁进行初始化
template <class T>
pthread_mutex_t ThreadPool<T>::instance_lock = PTHREAD_MUTEX_INITIALIZER;

这里有个细节需要注意
在实现GetInstance函数时，我们采取双检查加锁的方式
原因在于，加锁解锁必定要在临界区之前，否则将毫无意义，依旧会出现多个线程创建多个对象，出现并发问题
但是单例只会被创建一次，申请锁这个操作本身是一种消耗
因此我们在外层再套一层判断，假如不为空，则不会进去，也就不会再因为申请锁这个操作而白白消耗
提高效率的同时，还保证了线程安全
在这里插入图片描述

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

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

相关文章

【安装指南】MySQL和Navicat下载、安装及使用详细教程

【安装指南】MySQL和Navicat下载、安装及使用详细教程

目录 ⛳️1.【MySQL】安装教程 1.1 获取下载包 1.2 MySQL安装 1.2.1 MySQL工具安装 1.2.2 MySQL环境变量 1.2.3 验证MySQL安装成功 ⛳️2.【Navicat-v15】的安装和无限使用 ⛳️3.【测试Navicat连接MySQL】 ⛳️1.【MySQL】安装教程 1.1 获取下载包 前往官网获取压缩包…
阅读更多...
什么是虚拟化？如何监控虚拟化设备

什么是虚拟化？如何监控虚拟化设备

虚拟化是创建物理 IT 资源&#xff08;如服务器或桌面&#xff09;的虚拟版本的行为&#xff0c;虚拟机&#xff08;VM&#xff09;是在物理主机设备上创建的&#xff0c;VM 的行为与物理设备完全相同&#xff0c;并且可以从主机运行不同的操作系统。 例如&#xff0c;您可以在…
阅读更多...
网络篇---第六篇

网络篇---第六篇

系列文章目录 文章目录 系列文章目录前言一、HTTP1.0、HTTP1.1、HTTP2.0的关系和区别二、说说HTTP协议与TCP/IP协议的关系三、如何理解HTTP协议是无状态的？前言 前些天发现了一个巨牛的人工智能学习网站，通俗易懂，风趣幽默，忍不住分享一下给大家。点击跳转到网站，这篇文章…
阅读更多...
Swift构造器继承链

Swift构造器继承链

类类型的构造器代理 Swift构造器需遵循以下三大规则&#xff1a; 指定构造器必须调用它直接父类的指定构造器方法便利构造器必须调用同一个类中定义的其他初始化方法便利构造器在最后必须调用一个指定构造器 两段式构造过程 Swift 中类的构造过程包含两个阶段。第一个阶段&a…
阅读更多...
命令模式 rust和java实现

命令模式 rust和java实现

文章目录 命令模式介绍javarustrust仓库 命令模式 命令模式&#xff08;Command Pattern&#xff09;是一种数据驱动的设计模式。请求以命令的形式包裹在对象中&#xff0c;并传给调用对象。调用对象寻找可以处理该命令的合适的对象&#xff0c;并把该命令传给相应的对象&…
阅读更多...
企业如何选择安全又快速的大文件传输平台

企业如何选择安全又快速的大文件传输平台

在现代信息化社会&#xff0c;数据已经成为各个行业的重要资源&#xff0c;而数据的传输和交换则是数据价值的体现。在很多场合&#xff0c;企业需要传输或接收大文件&#xff0c;例如设计图纸、视频素材、软件开发包、数据库备份等。这些文件的大小通常在几百兆字节到几十个字…
阅读更多...
Vue 入门指南：从零开始学习 Vue 的基础知识

Vue 入门指南：从零开始学习 Vue 的基础知识

&#x1f95d;VUE官方文档 注意&#xff1a; &#x1f4d2;Vue 2 将于 2023 年 12 月 31 日停止维护。详见 Vue 2 延长 LTS。&#x1f4d2;Vue 2 中文文档已迁移至 v2.cn.vuejs.org。&#x1f4d2;想从 Vue 2 升级&#xff1f;请参考迁移指南。 文章目录 &#x1f341;前言&am…
阅读更多...
es集群相关报错信息

es集群相关报错信息

给es集群添加用户密码的时候&#xff0c;会自动弹出相关的账户信息&#xff0c;这个时候&#xff0c;只需要设置对应密码就可以了 [esuserjky-test1 bin]$ ./elasticsearch-setup-passwords interactive future versions of Elasticsearch will require Java 11; your Java ve…
阅读更多...
【Vue】【uni-app】实现发起工单页面

【Vue】【uni-app】实现发起工单页面

修改了上次的导航栏为二级导航 <template><view class"leftNav"><div class"logo">显鹅易见</div><uni-collapse class"item" accordion"true"><uni-collapse-item title"养殖场总部">…
阅读更多...
MySQL索引优化实战一

MySQL索引优化实战一

#插入一些示例数据drop procedure if exists insert_emp;delimiter ;;create procedure insert_emp()begindeclare i int;set i1;while(i<100000)doinsert into employees(name,age,position) values(CONCAT(tqq,i),i,dev);set ii1;end while;end;;delimiter ;call insert_e…
阅读更多...
java编程:数组代表着苹果期货在 9 天内的价格变化，其中第 n 个元素是苹果在第 n 天的 价格，你可以进行最多三次交易，设计算法，9 天内赚到最多的钱

java编程:数组代表着苹果期货在 9 天内的价格变化，其中第 n 个元素是苹果在第 n 天的 价格，你可以进行最多三次交易，设计算法，9 天内赚到最多的钱

1 题目 编程题&#xff1a;下面的数组代表着苹果期货在 9 天内的价格变化&#xff0c;其中第 n 个元素是苹果在第 n 天的 价格&#xff0c;你可以进行最多三次交易&#xff0c;设计一个算法&#xff0c;9 天内如何赚到最多的钱&#xff1f;价格数组&#xff1a; [8, 9, 2, 5, …
阅读更多...
医疗影像数据集—CT、X光、骨折、阿尔茨海默病MRI、肺部、肿瘤疾病等图像数据集

医疗影像数据集—CT、X光、骨折、阿尔茨海默病MRI、肺部、肿瘤疾病等图像数据集

最近收集了一大波关于CT、X光等医疗方面的数据集包含骨折、阿尔茨海默病MRI、肺部疾病等类型的医疗影像数据&#xff0c;废话不多说&#xff0c;给大家逐一介绍&#xff01;&#xff01; 1、彩色预处理阿尔茨海默病MRI(磁共振成像)图像数据集 彩色预处理阿尔茨海默病MRI(磁共…
阅读更多...
科普 | 隧道代理IP，简化操作提升安全性

科普 | 隧道代理IP，简化操作提升安全性

随着数字化时代的深入发展&#xff0c;企业对网络数据的依赖日益增强。在这样的背景下&#xff0c;隧道代理IP正在以其独特的优势改变传统的网络代理模式&#xff0c;为企业级数据采集领域带来革命性的变革。 隧道代理IP技术简介 隧道代理IP通过云端服务器实现自动化的HTTP代理…
阅读更多...
【Java Spring】Spring MVC基础

【Java Spring】Spring MVC基础

文章目录 1、Spring MVC 简介2、Spring MVC 功能1.1 Spring MVC 连接功能2.2 Spring MVC 获取参数2.2.1 获取变量2.2.2 获取对象2.2.3 RequestParam重命名后端参数2.2.4 RequestBody 接收Json对象2.2.5 PathVariable从URL中获取参数 1、Spring MVC 简介 Spring Web MVC是构建于…
阅读更多...
SEAM-STRESS

SEAM-STRESS

模型 PCM means ‘Pixel Correlation Module’ 辅助信息 作者未提供代码
阅读更多...
jetson nano 串口通信

jetson nano 串口通信

目录 1.UART通信介绍 2.电脑端准备工作 2.1 安装串口调试助手 2.2 硬件接线 3.Jetson Nano端准备工作 3.1安装库文件 3.2修改主板上电启动串口权限 4.示例程序-发送及接收 4.1 开启串口调试助手 4.2 导入示例程序 4.3 执行程序 4.4 查看效果 4.4.1 串口调试端 4.4…
阅读更多...
深入理解强化学习——马尔可夫决策过程：备份图（Backup Diagram）

深入理解强化学习——马尔可夫决策过程：备份图（Backup Diagram）

分类目录&#xff1a;《深入理解强化学习》总目录 在本文中&#xff0c;我们将介绍备份&#xff08;Backup&#xff09;的概念。备份类似于自举之间的迭代关系&#xff0c;对于某一个状态&#xff0c;它的当前价值是与它的未来价值线性相关的。 我们将与下图类似的图称为备份图…
阅读更多...
NX二次开发UF_MTX3_vec_multiply_t 函数介绍

NX二次开发UF_MTX3_vec_multiply_t 函数介绍

文章作者&#xff1a;里海 来源网站&#xff1a;https://blog.csdn.net/WangPaiFeiXingYuan UF_MTX3_vec_multiply_t Defined in: uf_mtx.h void UF_MTX3_vec_multiply_t(const double vec [ 3 ] , const double mtx [ 9 ] , double vec_product [ 3 ] ) overview 概述 Ret…
阅读更多...
rabbitMQ对优先级队列的使用

rabbitMQ对优先级队列的使用

注意事项&#xff1a; 1.队列设置优先级 权制范围&#xff08;0-255&#xff09;推荐0-10 否则浪费CPU与内存 2.发消息时给消息设置优先级 3.消息需要完全事先在队列中&#xff0c;在被消费者消费 会被排序&#xff0c;否则边生产边消费不会达到预期的队列优先效果。 优先级队列…
阅读更多...
plotneuralnet和netron结合绘制模型架构图

plotneuralnet和netron结合绘制模型架构图

plotneuralnet和netron结合绘制模型架构图 一、plotneuralnet 本身的操作 模型结构图的可视化&#xff0c;能直观展示模型的结构以及各个模块之间的关系。最近借助plotneuralnet python库&#xff08;windows版&#xff09;绘制了一个网络结构图&#xff0c;有一些经验和心得…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023