Linux之线程池

线程池

  • 线程池概念
  • 线程池的应用场景
  • 线程池实现原理
  • 单例模式下线程池实现
  • STL、智能指针和线程安全
  • 其他常见的各种锁

线程池概念

线程池：一种线程使用模式。

线程过多会带来调度开销，进而影响缓存局部性和整体性能。而线程池维护着多个线程，等待着监督管理者分配可并发执行的任务。

这避免了在处理短时间任务时创建与销毁线程的代价。线程池不仅能够保证内核的充分利用，还能防止过分调度。可用线程数量应该取决于可用的并发处理器、处理器内核、内存、网络sockets等的数量。

线程池的应用场景

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

线程池实现原理

线程池通过一个线程安全的阻塞任务队列加上一个或一个以上的线程实现，线程池中的线程可以从阻塞队列中获取任务进行任务处理，当线程都处于繁忙状态时可以将任务加入阻塞队列中，等到其它的线程空闲后进行处理。
在这里插入图片描述

testMain.cc

主线程任务逻辑启动线程，不断向任务队列中push任务就可以了，此时线程接收到任务就会进行处理：

#include <iostream>
#include <ctime>
#include <unistd.h>
#include "threadPool.hpp"
#include "Task.hpp"
#include "log.hpp"int main()
{srand((unsigned int)time(nullptr) ^ getpid());ThreadPool<Task>* tp = new ThreadPool<Task>();//启动线程tp->run();//主线程执行任务while(true){int x = rand() % 100 + 1;usleep(1000);int y = rand() % 50 + 1;Task t(x, y, [](int x, int y)->int{return x + y;});logMessage(DEBUG, "制作任务完成：%d+%d=?", x, y);// std::cout << "制作任务完成: " << x << "+" << y << "=?" << std::endl;//将任务推送到线程池中tp->pushTask(t);sleep(1);}return 0;
}

thread.hpp

我们对创建线程进行封装，包含线程名，线程个数，回调函数，线程ID等；

#pragma once#include <iostream>
#include <string>
#include <functional>
#include <cstdio>typedef void *(*func_t)(void *);class ThreadData
{
public:std::string name_;void *args_;
};class Thread
{
public:Thread(int num, func_t callback, void *args) : func_(callback){char nameBuffer[64];snprintf(nameBuffer, sizeof nameBuffer, "Thread-%d", num);name_ = nameBuffer;tdata_.args_ = args;tdata_.name_ = name_;}void start(){pthread_create(&tid_, nullptr, func_, (void *)&tdata_);}void join(){pthread_join(tid_, nullptr);}std::string name(){return name_;}~Thread(){}private:std::string name_; // 线程名int num_;          // 线程个数func_t func_;      // 回调函数pthread_t tid_;    // 线程IDThreadData tdata_;
};

threadPool.hpp

线程池中我们需要用注意的是：

  1. 需要用到条件变量与互斥锁，因为线程池中的任务队列会被多个执行流访问，所以我们必须引入互斥锁；
  2. 当线程池中任务队列为满时，我们此时push任务就无法push进去，此时就需要挂起等待，直到线程将某一任务执行完毕，唤醒等待队列，才可以继续进行push，我们执行任务也是一样，只有当任务队列中有任务时，我们才可以执行，否则就需要挂起等待，直到有任务生成才去获取任务；
  3. 线程执行例程需要设置为静态方法，原因如下：
  • 使用pthread_create函数创建线程时，需要为创建的线程传入一个routine（执行例程），该routine只有一个参数类型为void的参数，以及返回类型为void的返回值。因为我们将线程池封装为一个类，此时routine函数就包含两个参数，第一个参数就是隐含的this指针，直接用来创建线程程序是会报错的；
  • 静态成员函数属于类，而不属于某个对象，也就是说静态成员函数是没有隐藏的this指针的，因此我们需要将routine设置为静态方法，此时routine函数才真正只有一个参数类型为void*的参数。
  • 但是在静态成员函数内部无法调用非静态成员函数，而我们需要在routine函数当中调用该类的某些非静态成员函数，比如pop。因此我们需要在创建线程时，向routine函数传入的当前对象的this指针，此时我们就能够通过该this指针在routine函数内部调用非静态成员函数了。
#pragma once#include <iostream>
#include <vector>
#include <queue>
#include <unistd.h>
#include "thread.hpp"
#include "lockGuard.hpp"
#include "log.hpp"#define NUM 3template <class T>
class ThreadPool
{
public:pthread_mutex_t *getMutex(){return &lock;}bool isEmpty(){return task_queue_.empty();}void waitCond(){pthread_cond_wait(&cond, &lock);}T getTask(){T t = task_queue_.front();task_queue_.pop();return t;}public:ThreadPool(int thread_num = NUM) : num_(thread_num){pthread_mutex_init(&lock, nullptr);pthread_cond_init(&cond, nullptr);for (int i = 1; i <= num_; i++){threads_.push_back(new Thread(i, routine, this));}}// 生产void run(){for (auto &iter : threads_){iter->start();// std::cout << iter->name() << "启动成功" << std::endl;logMessage(NORMAL, "%s %s", iter->name().c_str(), "启动成功");}}static void *routine(void *args){ThreadData *td = (ThreadData *)args;ThreadPool<T> *tp = (ThreadPool<T> *)td->args_;while (true){T task;{LockGuard lockguard(tp->getMutex());while (tp->isEmpty())tp->waitCond();task = tp->getTask();}// 处理任务task(td->name_);}}void pushTask(const T &task){LockGuard lockguard(&lock);task_queue_.push(task);pthread_cond_signal(&cond);}~ThreadPool(){for (auto &iter : threads_){iter->join();delete iter;}pthread_mutex_destroy(&lock);pthread_cond_destroy(&cond);}private:std::vector<Thread *> threads_; // 线程组int num_;std::queue<T> task_queue_; // 任务队列pthread_mutex_t lock; // 互斥锁pthread_cond_t cond;  // 条件变量
};

lockGuard.hpp

为了代码更加的模块化，我们将互斥锁进行一个封装成一个RAII风格的锁，创建对象是调用构造函数加锁，出作用域调用析构函数解锁：

#pragma once#include <iostream>
#include <pthread.h>class Mutex
{
public:Mutex(pthread_mutex_t *mtx) : pmtx_(mtx){}void lock(){pthread_mutex_lock(pmtx_);}void unlock(){pthread_mutex_unlock(pmtx_);}~Mutex(){}private:pthread_mutex_t *pmtx_;
};class LockGuard
{
public:LockGuard(pthread_mutex_t* mtx) : mtx_(mtx){mtx_.lock();}~LockGuard(){mtx_.unlock();}private:Mutex mtx_;
};

Task.hpp

这是一个加法的计算任务：

#pragma once#include <iostream>
#include <string>
#include <functional>typedef std::function<int(int, int)> tfunc_t;class Task
{
public:Task(){}Task(int x, int y, tfunc_t func) : x_(x), y_(y), func_(func){}void operator()(const std::string& name){// std::cout << "线程 " << name << " 处理完成, 结果是: " << x_ << "+" << y_ << "=" << func_(x_, y_) << std::endl;logMessage(WARNING, "%s处理完成:%d+%d = %d | %s | %d", name.c_str(), x_, y_, func_(x_, y_), __FILE__, __LINE__);}private:int x_;int y_;tfunc_t func_;
};

log.hpp

此处我们在设置一个日志文件，完整的日志功能，至少: 日志等级 时间 支持用户自定义(日志内容, 文件行，文件名)；

#pragma once#include <iostream>
#include <string>
#include <functional>typedef std::function<int(int, int)> tfunc_t;class Task
{
public:Task(){}Task(int x, int y, tfunc_t func) : x_(x), y_(y), func_(func){}void operator()(const std::string& name){// std::cout << "线程 " << name << " 处理完成, 结果是: " << x_ << "+" << y_ << "=" << func_(x_, y_) << std::endl;logMessage(WARNING, "%s处理完成:%d+%d = %d | %s | %d", name.c_str(), x_, y_, func_(x_, y_), __FILE__, __LINE__);}private:int x_;int y_;tfunc_t func_;
};

运行代码后，我们就会发现此时就有4个线程，其中1个为主线程：
在这里插入图片描述
并且我们会发现这3个线程在处理时会呈现出一定的顺序性，因为主线程是每秒push一个任务，这3个线程只会有一个线程获取到该任务，其他线程都会在等待队列中进行等待，当该线程处理完任务后就会因为任务队列为空而排到等待队列的最后，当主线程再次push一个任务后会唤醒等待队列首部的一个线程，这个线程处理完任务后又会排到等待队列的最后，因此这3个线程在处理任务时会呈现出一定的顺序性。
在这里插入图片描述

单例模式下线程池实现

单例模式：指的就是一个类只能创建一个对象，该模式可以保证系统中该类只有一个实例，并提供一个访问它的全局访问点，该实例被所有程序模块共享。

接下来我们以懒汉模式为例，来实现我们的线程池：

  1. 首先，我们需要将线程池中构造函数设置为私有，因为我们不想让他被多次访问，同时我们也要防止赋值和拷贝的情况发生，我们需要将拷贝构造函数与赋值运算符重载函数设置为私有或者删除；
  2. 提供一个指向单例对象的static指针，并在程序入口之前先将其初始化为空；
  3. 提供一个全局访问点获取单例对象。

通过上述三点就可以将我们的代码做出如下改变：

threadPool.hpp

#pragma once#include <iostream>
#include <vector>
#include <queue>
#include <unistd.h>
#include "thread.hpp"
#include "lockGuard.hpp"
#include "log.hpp"#define NUM 3template <class T>
class ThreadPool
{
public:pthread_mutex_t *getMutex(){return &lock;}bool isEmpty(){return task_queue_.empty();}void waitCond(){pthread_cond_wait(&cond, &lock);}T getTask(){T t = task_queue_.front();task_queue_.pop();return t;}private:ThreadPool(int thread_num = NUM) : num_(thread_num){pthread_mutex_init(&lock, nullptr);pthread_cond_init(&cond, nullptr);for (int i = 1; i <= num_; i++){threads_.push_back(new Thread(i, routine, this));}}ThreadPool(const ThreadPool<T> &other) = delete;const ThreadPool<T> &operator=(const ThreadPool<T> &other) = delete;public:static ThreadPool<T> *getThreadPool(int num = NUM){if (thread_ptr == nullptr){LockGuard lockguard(&mutex);if (thread_ptr == nullptr){thread_ptr = new ThreadPool<T>(num);}}return thread_ptr;}// 生产void run(){for (auto &iter : threads_){iter->start();// std::cout << iter->name() << "启动成功" << std::endl;logMessage(NORMAL, "%s %s", iter->name().c_str(), "启动成功");}}static void *routine(void *args){ThreadData *td = (ThreadData *)args;ThreadPool<T> *tp = (ThreadPool<T> *)td->args_;while (true){T task;{LockGuard lockguard(tp->getMutex());while (tp->isEmpty())tp->waitCond();task = tp->getTask();}// 处理任务task(td->name_);}}void pushTask(const T &task){LockGuard lockguard(&lock);task_queue_.push(task);pthread_cond_signal(&cond);}~ThreadPool(){for (auto &iter : threads_){iter->join();delete iter;}pthread_mutex_destroy(&lock);pthread_cond_destroy(&cond);}private:std::vector<Thread *> threads_; // 线程组int num_;std::queue<T> task_queue_; // 任务队列pthread_mutex_t lock; // 互斥锁pthread_cond_t cond;  // 条件变量static ThreadPool<T> *thread_ptr;static pthread_mutex_t mutex;
};template <typename T>
ThreadPool<T> *ThreadPool<T>::thread_ptr = nullptr;template <typename T>
pthread_mutex_t ThreadPool<T>::mutex = PTHREAD_MUTEX_INITIALIZER;

我们需要注意的是getThreadPool函数在创建对象过程中需要双检查加锁，因为简单的在if语句前后进行加锁解锁操作的话，后续在获取创建的单例对象操作时就会进行大量无意义的加锁解锁操作，我们进行双检查操作以后，就会加锁之前在进行一次判断，不为空就直接返回，就避免了后序无意义的加锁解锁操作；

testMain.cc

#include <iostream>
#include <ctime>
#include <unistd.h>
#include "threadPool.hpp"
#include "Task.hpp"
#include "log.hpp"int main()
{srand((unsigned int)time(nullptr) ^ getpid());// ThreadPool<Task>* tp = new ThreadPool<Task>();//启动线程ThreadPool<Task>::getThreadPool()->run();//主线程执行任务while(true){int x = rand() % 100 + 1;usleep(1000);int y = rand() % 50 + 1;Task t(x, y, [](int x, int y)->int{return x + y;});logMessage(DEBUG, "制作任务完成：%d+%d=?", x, y);// std::cout << "制作任务完成: " << x << "+" << y << "=?" << std::endl;//将任务推送到线程池中ThreadPool<Task>::getThreadPool()->pushTask(t);sleep(1);}return 0;
}

STL、智能指针和线程安全

STL中的容器是否是线程安全的?

不是。原因是, STL 的设计初衷是将性能挖掘到极致, 而一旦涉及到加锁保证线程安全, 会对性能造成巨大的影响，而且对于不同的容器，加锁方式的不同, 性能可能也不同(例如hash表的锁表和锁桶)，因此 STL 默认不是线程安全. 如果需要在多线程环境下使用, 往往需要调用者自行保证线程安全。

智能指针是否是线程安全的?

  • 对于 unique_ptr, 由于只是在当前代码块范围内生效, 因此不涉及线程安全问题；
  • 对于 shared_ptr, 多个对象需要共用一个引用计数变量, 所以会存在线程安全问题；但是标准库实现的时候考虑到了这个问题,，基于原子操作(CAS)的方式保证 shared_ptr 能够高效,，原子的操作引用计数。

其他常见的各种锁

  • 悲观锁：在每次取数据时，总是担心数据会被其他线程修改，所以会在取数据前先加锁（读锁，写锁，行锁等），当其他线程想要访问数据时，被阻塞挂起。
  • 乐观锁：每次取数据时候，总是乐观的认为数据不会被其他线程修改，因此不上锁。但是在更新数据前，会判断其他数据在更新前有没有对数据进行修改。主要采用两种方式：版本号机制和CAS操作。
  • CAS操作：当需要更新数据时，判断当前内存值和之前取得的值是否相等。如果相等则用新值更新。若不等则失败，失败则重试，一般是一个自旋的过程，即不断重试。
  • 其次还有自旋锁，公平锁，非公平锁…

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

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

相关文章

基于机器视觉的手势检测和识别算法 计算机竞赛

基于机器视觉的手势检测和识别算法 计算机竞赛

0 前言 &#x1f525; 优质竞赛项目系列&#xff0c;今天要分享的是 基于深度学习的手势检测与识别算法 该项目较为新颖&#xff0c;适合作为竞赛课题方向&#xff0c;学长非常推荐&#xff01; &#x1f9ff; 更多资料, 项目分享&#xff1a; https://gitee.com/dancheng…
阅读更多...
【代码随想录】算法训练计划03

【代码随想录】算法训练计划03

1、203. 移除链表元素 题目&#xff1a; 给你一个链表的头节点 head 和一个整数 val &#xff0c;请你删除链表中所有满足 Node.val val 的节点&#xff0c;并返回 新的头节点 。 输入&#xff1a;head [1,2,6,3,4,5,6], val 6 输出&#xff1a;[1,2,3,4,5] 思路&#xf…
阅读更多...
linux进程间通信

linux进程间通信

文章目录 前言一、管道通信1、进程间通信目的2、进程间通信分类3、匿名管道通信3.1 匿名管道通信介绍3.2 匿名管道通信3.3 匿名管道读写规则3.4 匿名管道特点3.5 站在文件描述符角度-深度理解管道3.6 站在内核角度-管道本质 4、进程池练习5、命名管道6、匿名管道与命名管道的区…
阅读更多...
智慧公厕：细致入微的城市贴心服务与便捷方便的生活配套

智慧公厕：细致入微的城市贴心服务与便捷方便的生活配套

在现代城市生活中&#xff0c;公厕作为重要的城市基础设施&#xff0c;一直是城市发展的关键环节之一。然而&#xff0c;传统的公厕常常存在着设施陈旧、管理不善和卫生状况差等问题&#xff0c;给市民的生活品质和城市形象带来了一定的影响。为了提供更好的城市公厕服务&#…
阅读更多...
Python 框架学习 Django篇 (六) 数据表关联、ORM关联

Python 框架学习 Django篇 (六) 数据表关联、ORM关联

在后端服务器开发中&#xff0c;特别是前后端分离的架构中数据库是非常重要的&#xff0c;后端主要就是负责管理数据&#xff0c;而我们经常使用的mysql、oracle 都是关系型数据库&#xff0c;什么是关系型数据库&#xff1f;就是建立在关系模型基础上的数据库&#xff0c;而最…
阅读更多...
Sql Server中的表组织和索引组织（聚集索引结构，非聚集索引结构，堆结构）

Sql Server中的表组织和索引组织（聚集索引结构，非聚集索引结构，堆结构）

正文 SqlServer用三种方法来组织其分区中的数据或索引页&#xff1a; 1、聚集索引结构 聚集索引是按B树结构进行组织的&#xff0c;B树中的每一页称为一个索引节点。每个索引行包含一个键值和一个指针。指针指向B树上的某一中间级页&#xff08;比如根节点指向中间级节点中的…
阅读更多...
超全面测评！2023年最常用的15款原型设计工具

超全面测评！2023年最常用的15款原型设计工具

在互联网和软件行业中&#xff0c;原型设计是产品经理、交互设计师以及运营人员等职位必不可少的一门技能。原型设计工具的重要性也是人尽皆知&#xff0c;这都是因为原型设计工具是帮助设计者表达产品想法、功能设定及流程逻辑的最佳方式。 今天就为大家带来原型设计工具的相…
阅读更多...
「林曦的亲子美育」讲讲关于阅读的那些事儿

「林曦的亲子美育」讲讲关于阅读的那些事儿

「林曦的亲子美育」是“林曦的小世界”2023年策划的一档新栏目。林曦老师作为一个“小男生的妈妈”,在这些年分享了许多关于亲子教育的心得&#xff1a;以“美”作为连接和最高标准&#xff0c;会护持着小朋友的选择和人生。教育是一个生活的过程。做一餐饭、读一本书、看一张画…
阅读更多...
HCL模拟器选路实验案例

HCL模拟器选路实验案例

此选路题目选自职业院校技能竞赛中的一道题比较考验思路&#xff0c;适合于参加新华三杯大赛以及网络专业的同学&#xff0c;当做练习题目进行解题​​​​​​​ 题目 1.S1、S2、R1、R2运行ospf进程100&#xff0c;区域0&#xff0c;R1、R2、R3、R4、R5运行ospf进程200&#…
阅读更多...
Ocelot简易教程目录

Ocelot简易教程目录

Ocelot简易教程目录 这里写目录标题 Ocelot简易教程目录 Ocelot简易教程&#xff08;一&#xff09;之Ocelot是什么Ocelot简易教程&#xff08;二&#xff09;之快速开始1Ocelot简易教程&#xff08;二&#xff09;之快速开始2Ocelot简易教程&#xff08;三&#xff09;之主要特…
阅读更多...
安装虚拟机找不到虚拟网啦1（eth1）不出现

安装虚拟机找不到虚拟网啦1（eth1）不出现

一、安装虚拟机找不到虚拟网啦1&#xff08;eth1&#xff09;不出现 1、先安装virtualbox 2、再安装vagrant 3、在windows使用ipconfig没有VirtualBoxHost-OnlyNetWork解决方法 1) 解决办法 在windows的设置中找到 网络和Internet 选项&#xff0c;选择右侧 更改适配器选项 …
阅读更多...
微信小程序开发之投票管理及小程序UI的使用

微信小程序开发之投票管理及小程序UI的使用

目录 一、小程序UI 1.讲述 2. 介绍vantWeapp 3. 使用vantWeapp 安装 构建 依赖 引用 二、后端 1. 后端实体对象 2. 后端接口 3. 实现类 4. 请求处理类 三、前端 1. 定义路径 2. 页面引用 3. 页面 4. 页面美化 5. 数据 6. 效果展示 一、小程序UI 1.讲述 小…
阅读更多...
信息学奥赛一本通2061：【例1.2】梯形面积

信息学奥赛一本通2061：【例1.2】梯形面积

2061&#xff1a;【例1.2】梯形面积 时间限制: 1000 ms 内存限制: 65536 KB 提交数: 172550 通过数: 68183 【题目描述】 在梯形中阴影部分面积是150平方厘米&#xff0c;求梯形面积。 【输入】 (无&#xff09; 【输出】 输出梯形面积&#xff08;保留两位小数&a…
阅读更多...
HarmonyOS开发：NodeJs脚本实现组件化动态切换

HarmonyOS开发：NodeJs脚本实现组件化动态切换

前言 上篇文章&#xff0c;我们使用NodeJs脚本完成了HarmonyOS项目的组件化运行&#xff0c;但是由于脚本是基于4.0.0.400版本的DevEco Studio开发的&#xff0c;可能在配置文件的修改上有些许差距&#xff0c;那么遇到这种情况怎么办&#xff0c;一种是再写一套针对性的脚本文…
阅读更多...
【Oracle】[INS-30131]执行安装程序验证所需的初始设置失败。

【Oracle】[INS-30131]执行安装程序验证所需的初始设置失败。

这里写目录标题 一、问题描述1 报错内容1.1 无法从节点“kotin”检索 exectask 的版本1.2 工作目录"xxx"无法在节点"kotin"上使用 2 相关环境2.1 安装软件2.2 安装系统 3 解决思路分析 二、解决方案1 方案一、 满足验证条件 - 不换系统1.1 第一步、检查文件…
阅读更多...
p5.js 到底怎么设置背景图？

p5.js 到底怎么设置背景图？

本文简介 点赞 关注 收藏 学会了 在 《p5.js 光速入门》 里我们学过加载图片元素&#xff0c;学过过背景色的用法&#xff0c;但当时没提到背景图要怎么使用。 本文就把背景图这部分内容补充完整&#xff0c;并且会提到在 p5.js 里使用背景图的一些注意点。 背景图的用法…
阅读更多...
在虚拟环境中，通过pip安装tensorflow

在虚拟环境中，通过pip安装tensorflow

目录 激活python虚拟环境&#xff0c;更新pip 通过pip 安装tensorflow 确定python版本&#xff1a; ​编辑安装tensorflow: ​编辑 为什么使用pip安装tensorflow? 激活python虚拟环境&#xff0c;更新pip 命令为python -m pip install --upgrade pip 通过pip 安装tensorf…
阅读更多...
C语言之结构体和共用体详解

C语言之结构体和共用体详解

目录 结构体 结构体的定义和使用 结构体数组的使用 结构体指针的使用 结构体大小的计算 共用体 共用体的定义和使用 typedef用法详解 enum枚举类型 结构体 结构体的定义和使用 C语言的结构体&#xff08;Struct&#xff09;是一种自定义的数据类型&#xff0c;它允许…
阅读更多...
时间、空间复杂度的例题详解

时间、空间复杂度的例题详解

文章前言 上篇文章带大家认识了数据结构和算法的含义&#xff0c;以及理解了时间、空间复杂度&#xff0c;那么接下来来深入理解一下时间、空间复杂度。 时间复杂度实例 实例1 // 计算Func2的时间复杂度&#xff1f; void Func2(int N) {int count 0;for (int k 0; k <…
阅读更多...
图的应用4.0-----关键路径(AOE网)

图的应用4.0-----关键路径(AOE网)

目录 前言 AOE网 1.基本概念 2.应用 关键路径 1.算法理论 2.代码实现&#xff08;C/C&#xff09; 前言 前面学习了图AOV网的应用&#xff0c;即拓扑排序&#xff0c;那这一期我们学习AOE网的应用&#xff0c;这是一个图的一个很广泛问题&#xff0c;也就是关键路径。那…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023