多线程(进程池代码)

线程池介绍

那究竟什么是线程池呢?

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

线程过多会带来调度开销,进而影响缓存局部性和整体性能.
而线程池维护着多个线程,等待着监督管理者分配可并发执行的任务.
这避免了在处理短时间任务时创建与销毁线程的代价.
线程池不仅能够保证内核的充分利用,还能防止过分调度.
前面我们介绍过生产者消费者模型,线程池其实看作是它的一个变型
把任务队列和消费者(线程)进行了封装,统称为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,一经查实,立即删除!

相关文章

19元月租的流量卡有长期套餐吗?看看你选对流量卡了吗!

当我们购买流量卡时&#xff0c;会看到有很多宣传19元长期套餐的流量了&#xff0c;那么这些宣传是真的还是假的呢&#xff1f; ​  其实据小编了解&#xff0c;如果是你在网上申请的大流量卡&#xff0c;而且是运营商推出的正规流量卡&#xff0c;在没有任何套路的情况下&a…

【安装指南】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 获取下载包 前往官网获取压缩包…

企业认为绩效考核艰难的原因

考核指标是绩效管理的基础和依据&#xff0c;是所有工作的出发点&#xff0c;所谓差之毫厘&#xff0c;谬以千里&#xff0c;若考核所选指标有问题&#xff0c;那由此导出的结果必然有问题。 绩效管理&#xff0c;绝对是企业管理中处境最尴尬、令人又爱又恨的一项工作明知它是…

如何利用BI系统

随着技术的深度发展&#xff0c;企业内部的各类数据已经受到了前所未有的重视&#xff0c;越来越多的企业已经重视了商业智能BI系统对于企业内部数据的分析作用。BI系统可以帮助企业更好的理清楚数据和做出相对的决策&#xff0c;从而有了决策依据和提升企业的运转效率。那么如…

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

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

网络篇---第六篇

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

flutter TextField 控制焦点位置

背景 使用Visibility来控制清理按钮的显示和隐藏&#xff0c;在设置Visibility的状态时&#xff0c;会导致TextField焦点丢失。使用AnimatedOpacity代替Visibility 在光标丢失后手动设置光标位置 void _setFocus({int? baseOffset}) {final int currentPosition baseOffset ?…

Swift构造器继承链

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

命令模式 rust和java实现

文章目录 命令模式介绍javarustrust仓库 命令模式 命令模式&#xff08;Command Pattern&#xff09;是一种数据驱动的设计模式。请求以命令的形式包裹在对象中&#xff0c;并传给调用对象。调用对象寻找可以处理该命令的合适的对象&#xff0c;并把该命令传给相应的对象&…

Go语言简要介绍

Golang是一种编程语言&#xff0c;也称为Go或者Go语言。它是由Google开发的一种编译型、静态类型的语言。Golang的目标是提高程序开发的效率&#xff0c;同时保证程序的性能和安全。 Golang在语法结构上类似于C语言&#xff0c;但是通过引入新的概念和语法&#xff0c;比如gor…

Springboot 中 指定 AspectJ 的织入模式

在Spring Boot中&#xff0c;AspectJ的织入模式可以通过以下两种方式进行明确指定&#xff1a; 使用配置文件&#xff08;application.properties或application.yml&#xff09;&#xff1a;在Spring Boot的配置文件中&#xff0c;可以添加以下属性来指定AspectJ的织入模式&am…

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

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

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集群添加用户密码的时候&#xff0c;会自动弹出相关的账户信息&#xff0c;这个时候&#xff0c;只需要设置对应密码就可以了 [esuserjky-test1 bin]$ ./elasticsearch-setup-passwords interactive future versions of Elasticsearch will require Java 11; your Java ve…

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

修改了上次的导航栏为二级导航 <template><view class"leftNav"><div class"logo">显鹅易见</div><uni-collapse class"item" accordion"true"><uni-collapse-item title"养殖场总部">…

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…

vue 浏览器版本兼容问题解决方案

1、 为了使 Vue.js 兼容 IE、360 等浏览器&#xff0c;你可能需要添加一些额外的依赖。以下是一些常用的依赖项&#xff1a; &#xff08;1&#xff09;Babel&#xff1a;Babel 是一个 JavaScript 编译器&#xff0c;可以将 ES6 的语法转换成 ES5 语法&#xff0c;以便支持老旧…

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、肺部疾病等类型的医疗影像数据&#xff0c;废话不多说&#xff0c;给大家逐一介绍&#xff01;&#xff01; 1、彩色预处理阿尔茨海默病MRI(磁共振成像)图像数据集 彩色预处理阿尔茨海默病MRI(磁共…

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

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