【Linux】使用管道实现一个简易版本的进程池

文章目录

  • 使用管道实现一个简易版本的进程池
    • 流程图
    • 代码
      • makefile
      • Task.hpp
      • ProcessPool.cc
    • 程序流程：

使用管道实现一个简易版本的进程池

流程图

bd6b8d79d30bd281ae2d181d5a7fa689

代码

makefile

ProcessPool:ProcessPool.ccg++ -o $@ $^ -g -std=c++11
.PHONY:clean
clean:rm -f ProcessPool

Task.hpp

#pragma once#include <iostream>
#include <vector>typedef void (*task_t)(); //定义了一个函数指针类型task_t，它指向返回类型为void且不接受任何参数的函数。void task1()
{std::cout << "lol 刷新日志" << std::endl;
}
void task2()
{std::cout << "lol 更新野区，刷新出来野怪" << std::endl;
}
void task3()
{std::cout << "lol 检测软件是否更新,如果需要，就提示用户" << std::endl;
}
void task4()
{std::cout << "lol 用户释放技能，更新用的血量和蓝量" << std::endl;
}void LoadTask(std::vector<task_t> *tasks) // 该函数接受一个指向std::vector<task_t>的指针，并将其作为参数
{tasks->push_back(task1); //将task1函数的地址添加到向量中。tasks->push_back(task2);tasks->push_back(task3);tasks->push_back(task4);
}

ProcessPool.cc

#include "Task.hpp"  // 包含任务相关的头文件
#include <string>
#include <vector>
#include <cstdlib>
#include <ctime>
#include <cassert>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/wait.h>const int processnum = 10;  // 设定进程池大小为10
std::vector<task_t> tasks; // 存储任务的向量// 定义channel类，用于管理进程间通信
class channel
{
public:channel(int cmdfd, int slaverid, const std::string &processname):_cmdfd(cmdfd), _slaverid(slaverid), _processname(processname){}
public:int _cmdfd;               // 用于向子进程发送命令的文件描述符pid_t _slaverid;          // 子进程IDstd::string _processname; // 子进程名称，用于日志显示
};// 子进程执行的函数
void slaver()
{while(true){int cmdcode = 0;// 从标准输入(被重定向到管道)读取命令int n = read(0, &cmdcode, sizeof(int)); if(n == sizeof(int)){std::cout <<"slaver say@ get a command: "<< getpid() << " : cmdcode: " <<  cmdcode << std::endl;// 执行对应的任务if(cmdcode >= 0 && cmdcode < tasks.size()) tasks[cmdcode]();}if(n == 0) break; // 管道关闭时退出}
}// 初始化进程池
void InitProcessPool(std::vector<channel> *channels)
{std::vector<int> oldfds;  // 存储历史文件描述符for(int i = 0; i < processnum; i++){int pipefd[2];int n = pipe(pipefd);  // 创建管道assert(!n);(void)n;pid_t id = fork();     // 创建子进程if(id == 0) // 子进程{// 关闭历史文件描述符std::cout << "child: " << getpid() << " close history fd: ";for(auto fd : oldfds) {std::cout << fd << " "; // 打印当前文件描述符的值，用于显示子进程正在关闭哪些文件描述符。close(fd); // 关闭文件描述符}std::cout << "\n";close(pipefd[1]);  // 关闭写端dup2(pipefd[0], 0);  // 将管道读端重定向到标准输入close(pipefd[0]); //关闭读端slaver();          // 执行子进程任务std::cout << "process : " << getpid() << " quit" << std::endl;exit(0);}// 父进程close(pipefd[0]);  // 关闭读端// 创建新的channel并添加到channels中std::string name = "process-" + std::to_string(i);channels->push_back(channel(pipefd[1], id, name));oldfds.push_back(pipefd[1]);sleep(1);}
}// 打印调试信息
void Debug(const std::vector<channel> &channels)
{for(const auto &c :channels){std::cout << c._cmdfd << " " << c._slaverid << " " << c._processname << std::endl;}
}// 显示菜单
void Menu()
{std::cout << "################################################" << std::endl;std::cout << "# 1. 刷新日志             2. 刷新出来野怪        #" << std::endl;std::cout << "# 3. 检测软件是否更新      4. 更新用的血量和蓝量  #" << std::endl;std::cout << "#                         0. 退出               #" << std::endl;std::cout << "#################################################" << std::endl;
}// 控制子进程执行任务
void ctrlSlaver(const std::vector<channel> &channels)
{int which = 0;while(true){int select = 0;Menu();std::cout << "Please Enter@ ";std::cin >> select;if(select <= 0 || select >= 5) break;int cmdcode = select - 1;// 轮询方式分配任务给子进程std::cout << "father say: " << " cmdcode: " <<cmdcode << " already sendto " << channels[which]._slaverid << " process name: " << channels[which]._processname << std::endl;write(channels[which]._cmdfd, &cmdcode, sizeof(cmdcode));which++;which %= channels.size();}
}// 清理进程池
void QuitProcess(const std::vector<channel> &channels)
{for(const auto &c : channels){close(c._cmdfd);  // 关闭所有管道waitpid(c._slaverid, nullptr, 0);  // 等待所有子进程结束}
}int main()
{LoadTask(&tasks);  // 加载任务列表srand(time(nullptr)^getpid()^1023);  // 初始化随机数种子std::vector<channel> channels; //InitProcessPool(&channels);  // 初始化进程池ctrlSlaver(channels);  // 控制子进程执行任务QuitProcess(channels);  // 清理进程池return 0;
}

程序流程：

1.main函数首先调用LoadTask(&tasks)，将task1到task4四个任务的函数地址存入全局tasks向量。

2.srand(time(nullptr)^getpid()^1023); 初始化随机数种子

3.std::vector<channel> channels;，这行代码的作用是定义一个名为 channels 的向量（std::vector），用于存储 channel 类型的对象。它的主要作用是管理多个 channel 对象，每个 channel 对象代表一个子进程的通信通道。

  • 每个 channel 对象包含以下信息：

    • _cmdfd：用于向子进程发送命令的文件描述符（管道写端）。

    • _slaverid：子进程的进程ID（PID）。

    • _processname：子进程的名称，用于日志和调试。

  • channels 向量存储了所有子进程的通信信息，父进程可以通过它管理所有子进程。

4.InitProcessPool(&channels); ，初始化进程池

// 初始化进程池
void InitProcessPool(std::vector<channel> *channels)
{std::vector<int> oldfds;  // 存储历史文件描述符for(int i = 0; i < processnum; i++){int pipefd[2];int n = pipe(pipefd);  // 创建管道assert(!n);(void)n;pid_t id = fork();     // 创建子进程if(id == 0) // 子进程{// 关闭历史文件描述符std::cout << "child: " << getpid() << " close history fd: ";for(auto fd : oldfds) {std::cout << fd << " ";close(fd);}std::cout << "\n";close(pipefd[1]);  // 关闭写端dup2(pipefd[0], 0);  // 将管道读端重定向到标准输入close(pipefd[0]); //关闭读端slaver();          // 执行子进程任务std::cout << "process : " << getpid() << " quit" << std::endl;exit(0);}// 父进程close(pipefd[0]);  // 关闭读端// 创建新的channel并添加到channels中std::string name = "process-" + std::to_string(i);channels->push_back(channel(pipefd[1], id, name));oldfds.push_back(pipefd[1]);sleep(1);}
}

5.std::vector<int> oldfds; 的作用是存储父进程中已经创建的管道的写端文件描述符（pipefd[1]）。它的主要目的是在创建新的子进程时，确保子进程能够关闭不需要的文件描述符，避免资源泄露和潜在的问题。

为什么需要 oldfds？

  1. 文件描述符的继承：

    • 当父进程通过 fork() 创建子进程时，子进程会继承父进程的所有打开的文件描述符。

    • 如果父进程创建了多个管道（每个子进程对应一个管道），那么每个子进程都会继承所有管道的文件描述符，即使这些管道是用于其他子进程的。

  2. 资源泄露问题：

    • 如果子进程不关闭不需要的文件描述符，这些文件描述符会一直保持打开状态，导致资源泄露。

    • 例如，假设父进程创建了 10 个子进程，每个子进程都会继承 10 个管道的文件描述符，但实际上每个子进程只需要一个管道的读端文件描述符。

  3. 避免干扰：

    • 如果子进程不关闭不需要的文件描述符，可能会导致意外的行为。例如，某个子进程可能会错误地读取其他子进程的管道数据。

6.for(int i = 0; i < processnum; i++)，循环 processnum=10 次，每次创建一个子进程和一个管道。

7.int pipefd[2];

pipefd 是一个长度为 2 的整型数组，用于存储管道的两个文件描述符：

  • pipefd[0]：管道的 读端文件描述符，用于从管道中读取数据。
  • pipefd[1]：管道的 写端文件描述符，用于向管道中写入数据。

8.int n = pipe(pipefd);

调用 pipe 系统函数来创建一个管道，并将结果存储在变量 n 中。

1. pipe 系统函数的作用

pipe 是一个系统调用，用于创建一个管道。管道的本质是一个内核缓冲区，用于在两个进程之间传递数据。管道有两个端点：

  • 读端：用于从管道中读取数据。
  • 写端：用于向管道中写入数据。

pipe 函数的原型如下：

int pipe(int pipefd[2]);

2. 参数 pipefd[2]

  • pipefd 是一个长度为 2 的整型数组，用于存储管道的两个文件描述符：
    • pipefd[0]：管道的 读端文件描述符，用于从管道中读取数据。
    • pipefd[1]：管道的 写端文件描述符，用于向管道中写入数据。

3. 返回值 n

  • 如果 pipe 调用成功，返回 0。
  • 如果 pipe 调用失败，返回 -1，并设置 errno 表示错误原因。

4. 代码解析

int n = pipe(pipefd);
  • pipe(pipefd)：调用 pipe 函数创建管道。
  • n：存储 pipe 函数的返回值，用于检查管道是否创建成功。

9.assert(!n);，(void)n;

  • assert(!n)：确保管道创建成功。如果 pipe 调用失败，程序会终止。
  • (void)n：忽略未使用的变量警告。

10.pid_t id = fork(); ，创建子进程

if(id == 0) // 子进程
{// 关闭历史文件描述符std::cout << "child: " << getpid() << " close history fd: ";for(auto fd : oldfds) {std::cout << fd << " ";close(fd);}std::cout << "\n";close(pipefd[1]);  // 关闭写端dup2(pipefd[0], 0);  // 将管道读端重定向到标准输入close(pipefd[0]); //关闭读端slaver();          // 执行子进程任务std::cout << "process : " << getpid() << " quit" << std::endl;exit(0);
}

11.在子进程中，id 为 0。

12.std::cout << "child: " << getpid() << " close history fd: ";

打印当前子进程的PID，用于区分不同子进程

" close history fd: "，说明接下来要关闭的文件描述符

for(auto fd : oldfds) {std::cout << fd << " ";// 打印当前文件描述符的值，用于显示子进程正在关闭哪些文件描述符。close(fd);// 关闭文件描述符
}

在子进程中遍历 oldfds 向量，关闭所有不需要的文件描述符。

具体来说，它的目的是确保子进程只保留与自己相关的文件描述符，关闭其他无关的文件描述符，从而避免资源泄露和潜在的问题。

close(pipefd[1]);  // 子进程关闭写端，因为子进程只需要读取命令
dup2(pipefd[0], 0);  // 将父进程管道读端重定向到标准输入
close(pipefd[0]); //关闭父进程读端
slaver();          // 执行子进程任务

dup2函数将管道的读端(pipefd[0])复制到标准输入(0)

这意味着之后从标准输入读取的数据实际上是从管道读取的

后续代码中可以直接使用read(0,…)来读取父进程发送的数据

数据流向：父进程 ---> 写端(pipefd[1]) ---> 管道 ---> 读端(重定向到标准输入) ---> 子进程

子进程：

  • 关闭写端(pipefd[1])
  • 将读端重定向到标准输入
  • 关闭原读端(因为已重定向)

15.进入子进程函数

// 子进程执行的函数
void slaver()
{while(true){int cmdcode = 0;// 从标准输入(被重定向到管道)读取命令int n = read(0, &cmdcode, sizeof(int)); if(n == sizeof(int)){std::cout <<"slaver say@ get a command: "<< getpid() << " : cmdcode: " <<  cmdcode << std::endl;// 执行对应的任务if(cmdcode >= 0 && cmdcode < tasks.size()) tasks[cmdcode]();}if(n == 0) break; // 管道关闭时退出}
}

while(true)，无限循环，持续监听命令

int cmdcode = 0;
int n = read(0, &cmdcode, sizeof(int));

read(0, …)：从标准输入读取数据，因为前面做了重定向，实际是从管道读取

&cmdcode：存储读取数据的地址

sizeof(int)：读取int大小的数据

n：返回实际读取的字节数

if(n == sizeof(int)) {  // 成功读取到完整的命令// 打印调试信息std::cout <<"slaver say@ get a command: "<< getpid() << " : cmdcode: " <<  cmdcode << std::endl;// 执行对应任务if(cmdcode >= 0 && cmdcode < tasks.size()) tasks[cmdcode]();  // 调用任务函数
}

if(cmdcode >= 0 && cmdcode < tasks.size())，确保cmdcode非负，确保cmdcode小于任务数组大小，防止数组越界访问

tasks[cmdcode]();，tasks[cmdcode]获取对应的函数指针，()操作符调用该函数。

// 假设cmdcode = 0
tasks[0](); // 调用task1()，输出"lol 刷新日志"// 假设cmdcode = 1
tasks[1](); // 调用task2()，输出"lol 更新野区，刷新出来野怪"// 假设cmdcode = 2
tasks[2](); // 调用task3()，输出"lol 检测软件是否更新"// 假设cmdcode = 3
tasks[3](); // 调用task4()，输出"lol 更新用户血量和蓝量"

if(n == 0) break; ，管道关闭时退出

16.slaver()结束，返回刚刚的

std::cout << "process : " << getpid() << " quit" << std::endl; //打印退出信息,getpid帮助我们确认哪个进程正在退出
exit(0); // 立即终止当前进程

17.然后执行InitProcessPool()函数的剩下来部分

// 父进程
close(pipefd[0]);  // 关闭读端// 创建新的channel并添加到channels中
std::string name = "process-" + std::to_string(i);
channels->push_back(channel(pipefd[1], id, name));
oldfds.push_back(pipefd[1]);sleep(1);

close(pipefd[0]);，父进程只需写入命令，不需要读。及时关闭不需要的文件描述符

std::string name = "process-" + std::to_string(i);，为每个子进程创建唯一名称。

std::to_string(i) : 将数字i转为字符串，“+” : 字符串拼接运算符。

效果如：process-0, process-1, process-2…

channels->push_back(channel(pipefd[1], id, name));，push_back在容器末尾添加新元素。创建临时 channel 对象并添加到 vector

channel是一个结构体，存储子进程信息：

void InitProcessPool(std::vector<channel> *channels)struct channel {int fd;      // 管道写端pid_t pid;   // 子进程IDstd::string name;  // 进程名称channel(int _fd, pid_t _pid, const std::string& _name): fd(_fd), pid(_pid), name(_name){}
};

oldfds.push_back(pipefd[1]);，添加管道写端的文件描述符。

保存文件描述符的用途：

  • 用于后续关闭文件描述符
  • 防止文件描述符泄漏
  • 进程间通信的管理
  • 资源清理

sleep(1);，休眠1s。

18.进入main函数，执行ctrlSlaver(channels);

// 控制子进程执行任务
void ctrlSlaver(const std::vector<channel> &channels)
{int which = 0;while(true){int select = 0;Menu();std::cout << "Please Enter@ ";std::cin >> select;if(select <= 0 || select >= 5) break;int cmdcode = select - 1;// 轮询方式分配任务给子进程std::cout << "father say: " << " cmdcode: " <<cmdcode << " already sendto " << channels[which]._slaverid << " process name: " << channels[which]._processname << std::endl;write(channels[which]._cmdfd, &cmdcode, sizeof(cmdcode));which++;which %= channels.size();}
}

轮询机制

int which = 0;  // 轮询索引
which++;
which %= channels.size();  // 循环轮询

实现了循环分配任务给不同子进程

如果有3个进程，which的值会是 0,1,2,0,1,2…

任务选择

while(true) {int select = 0;Menu();  // 显示菜单std::cout << "Please Enter@ ";std::cin >> select;  // 获取用户输入if(select <= 0 || select >= 5) break;  // 退出条件int cmdcode = select - 1;  // 将用户输入的选项编号转换为程序内部使用的命令代码。
}

发送任务示例

// 显示任务分配信息
std::cout << "father say: " << " cmdcode: " << cmdcode << " already sendto " << channels[which]._slaverid << " process name: " << channels[which]._processname << std::endl;// 向子进程发送命令
write(channels[which]._cmdfd, &cmdcode, sizeof(cmdcode));

cmdcode要执行的命令编号（0代表hello，1代表calc等）

_slaverid: 子进程的PID（进程ID）

_processname: 子进程的名称

write(channels[which]._cmdfd, &cmdcode, sizeof(cmdcode));

channels[which]._cmdfd：管道的写端文件描述符

&cmdcode：命令代码的地址

sizeof(cmdcode)：发送的字节数（int类型通常是4字节）

19.返回主函数，执行QuitProcess(channels);，清理进程池。

void QuitProcess(const std::vector<channel> &channels)
{// 遍历所有channel对象for(const auto &c : channels){// 1. 关闭管道close(c._cmdfd);  // 关闭管道写端// 2. 等待子进程结束waitpid(c._slaverid, nullptr, 0);  // 阻塞等待直到子进程结束}
}

20.return 0；

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

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

相关文章

Elasticsearch的索引生命周期管理

Elasticsearch的索引生命周期管理

目录 说明零、参考一、ILM的基本概念二、ILM的实践步骤Elasticsearch ILM策略中的“最小年龄”是如何计算的&#xff1f;如何监控和调整Elasticsearch ILM策略的性能&#xff1f; 1. **监控性能**使用/_cat/thread_pool API基本请求格式请求特定线程池的信息响应内容 2. **调整…
阅读更多...
MQTT知识

MQTT知识

MQTT协议 MQTT 是一种基于发布/订阅模式的轻量级消息传输协议&#xff0c;专门针对低带宽和不稳定网络环境的物联网应用而设计&#xff0c;可以用极少的代码为联网设备提供实时可靠的消息服务。MQTT 协议广泛应用于物联网、移动互联网、智能硬件、车联网、智慧城市、远程医疗、…
阅读更多...
LabVIEW如何高频采集温度数据?

LabVIEW如何高频采集温度数据?

在LabVIEW中进行高频温度数据采集时&#xff0c;选择合适的传感器&#xff08;如热电偶或热电阻&#xff09;和采集硬件是关键。下面是一些建议&#xff0c;帮助实现高效的温度数据采集&#xff1a; 1. 传感器选择&#xff1a; 热电偶&#xff08;Thermocouple&#xff09;&am…
阅读更多...
前端 | 深入理解Promise

前端 | 深入理解Promise

1. 引言 JavaScript 是一种单线程语言&#xff0c;这意味着它一次仅能执行一个任务。为了处理异步操作&#xff0c;JavaScript 提供了回调函数&#xff0c;但是随着项目处理并发任务的增加&#xff0c;回调地狱 (Callback Hell) 使异步代码很难维护。为此&#xff0c;ES6带来了…
阅读更多...
gesp(C++六级)（10）洛谷：P10722：[GESP202406 六级] 二叉树

gesp(C++六级)（10）洛谷：P10722：[GESP202406 六级] 二叉树

gesp(C六级)&#xff08;10&#xff09;洛谷&#xff1a;P10722&#xff1a;[GESP202406 六级] 二叉树 题目描述 小杨有⼀棵包含 n n n 个节点的二叉树&#xff0c;且根节点的编号为 1 1 1。这棵二叉树任意⼀个节点要么是白色&#xff0c;要么是黑色。之后小杨会对这棵二叉树…
阅读更多...
【UE】 APlayerState

【UE】 APlayerState

APlayerState 定义和功能 APlayerState用于保存关于游戏玩家状态的信息&#xff0c;例如得分、玩家名称和其他统计数据。这些信息通常在多人游戏中被用来持续跟踪玩家的表现。设计理念 APlayerState的目的是提供一个存储和传输玩家特定信息的方法&#xff0c;这样即使玩家的控…
阅读更多...
如何用微信小程序写春联

如何用微信小程序写春联

​ 生活没有模板，只需心灯一盏。 如果笑能让你释然，那就开怀一笑；如果哭能让你减压，那就让泪水流下来。如果沉默是金，那就不用解释；如果放下能更好地前行，就别再扛着。 一、引入 Vant UI 1、通过 npm 安装 npm i @vant/weapp -S --production​​ 2、修改 app.json …
阅读更多...
C# Winform enter键怎么去关联button

C# Winform enter键怎么去关联button

1.关联按钮上的Key事件按钮上的keypress&#xff0c;keydown&#xff0c;keyup事件随便一个即可private void textBox1_KeyDown(object sender, KeyEventArgs e){if (e.KeyCode Keys.Enter){this.textBox2.Focus();}}2.窗体上的事件private void textBox2_KeyPress(object sen…
阅读更多...
FPGA 使用 CLOCK_DEDICATED_ROUTE 约束

FPGA 使用 CLOCK_DEDICATED_ROUTE 约束

使用 CLOCK_DEDICATED_ROUTE 约束 CLOCK_DEDICATED_ROUTE 约束通常在从一个时钟区域中的时钟缓存驱动到另一个时钟区域中的 MMCM 或 PLL 时使 用。默认情况下&#xff0c; CLOCK_DEDICATED_ROUTE 约束设置为 TRUE &#xff0c;并且缓存 /MMCM 或 PLL 对必须布局在相同…
阅读更多...
Ollama+OpenWebUI部署本地大模型

Ollama+OpenWebUI部署本地大模型

OllamaOpenWebUI部署本地大模型 前言 Ollama是一个强大且易于使用的本地大模型推理框架&#xff0c;它专注于简化和优化大型语言模型&#xff08;LLMs&#xff09;在本地环境中的部署、管理和推理工作流。可以将Ollama理解为一个大模型推理框架的后端服务。 Ollama Ollama安…
阅读更多...
SpringBoot 整合 SpringMVC：SpringMVC的注解管理

SpringBoot 整合 SpringMVC：SpringMVC的注解管理

分类&#xff1a; 中央转发器(DispatcherServlet)控制器视图解析器静态资源访问消息转化器格式化静态资源管理 中央转发器&#xff1a; 中央转发器被 SpringBoot 自动接管&#xff0c;不需要我们在 web.xml 中配置&#xff1a; <servlet><servlet-name>chapter2&l…
阅读更多...
Zemax 中带有体素探测器的激光谐振腔

Zemax 中带有体素探测器的激光谐振腔

激光谐振腔是激光系统的基本组成部分&#xff0c;在光的放大和相干激光辐射的产生中起着至关重要的作用。 激光腔由两个放置在光学谐振器两端的镜子组成。一个镜子反射率高&#xff08;后镜&#xff09;&#xff0c;而另一个镜子部分透明&#xff08;输出耦合器&#xff09;。…
阅读更多...
【Numpy核心编程攻略：Python数据处理、分析详解与科学计算】2.5 高级索引应用：图像处理中的区域提取

【Numpy核心编程攻略：Python数据处理、分析详解与科学计算】2.5 高级索引应用：图像处理中的区域提取

2.5 高级索引应用&#xff1a;图像处理中的区域提取 目录/提纲 #mermaid-svg-BI09xc20YqcpUam7 {font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}#mermaid-svg-BI09xc20YqcpUam7 .error-icon{fill:#552222;}#mermaid-svg-BI09xc20…
阅读更多...
[免费]微信小程序智能商城系统(uniapp+Springboot后端+vue管理端)【论文+源码+SQL脚本】

[免费]微信小程序智能商城系统(uniapp+Springboot后端+vue管理端)【论文+源码+SQL脚本】

大家好&#xff0c;我是java1234_小锋老师&#xff0c;看到一个不错的微信小程序智能商城系统(uniappSpringboot后端vue管理端)&#xff0c;分享下哈。 项目视频演示 【免费】微信小程序智能商城系统(uniappSpringboot后端vue管理端) Java毕业设计_哔哩哔哩_bilibili 项目介绍…
阅读更多...
本地部署DeepSeek-R1保姆级教程

本地部署DeepSeek-R1保姆级教程

近期&#xff0c;我国一款开源模型 DeepSeek-R1以低成本和高性能震撼了全球科技界。该模型的开源性使开发者能够在本地环境中部署和运行&#xff0c;提供了更高的灵活性和控制力。如果你也想在本地部署 DeepSeek-R1&#xff0c;可以参考以下完整的教程&#xff0c;涵盖Mac 版本…
阅读更多...
仿真设计|基于51单片机的贪吃蛇游戏

仿真设计|基于51单片机的贪吃蛇游戏

目录 具体实现功能 设计介绍 51单片机简介 资料内容 仿真实现&#xff08;protues8.7&#xff09; 程序&#xff08;Keil5&#xff09; 全部内容 资料获取 具体实现功能 利用单片机8*8点阵实现贪吃蛇游戏的控制。 仿真演示视频&#xff1a; 51-基于51单片机的贪吃蛇游…
阅读更多...
【4Day创客实践入门教程】Day2 探秘微控制器——单片机与MicroPython初步

【4Day创客实践入门教程】Day2 探秘微控制器——单片机与MicroPython初步

Day2 探秘微控制器——单片机与MicroPython初步 目录 Day2 探秘微控制器——单片机与MicroPython初步MicroPython语言基础开始基础语法注释与输出变量模块与函数 单片机基础后记 Day0 创想启程——课程与项目预览Day1 工具箱构建——开发环境的构建Day2 探秘微控制器——单片机…
阅读更多...
ubuntu 下使用deepseek

ubuntu 下使用deepseek

安装Ollama sudo snap install ollama 执行 ollama run deepseek-coder 然后进行等待。。。
阅读更多...
消息队列应用示例MessageQueues-STM32CubeMX-FreeRTOS《嵌入式系统设计》P343-P347

消息队列应用示例MessageQueues-STM32CubeMX-FreeRTOS《嵌入式系统设计》P343-P347

消息队列 使用信号量、事件标志组和线标志进行任务同步时&#xff0c;只能提供同步的时刻信息&#xff0c;无法在任务之间进行数据传输。要实现任务间的数据传输&#xff0c;一般使用两种方式&#xff1a; 1. 全局变量 在 RTOS 中使用全局变量时&#xff0c;必须保证每个任务…
阅读更多...
本地缓存～

本地缓存～

前言 Caffeine是使用Java8对Guava缓存的重写版本&#xff0c;在Spring Boot 2.0中取而代之&#xff0c;基于LRU算法实现&#xff0c;支持多种缓存过期策略。 以下摘抄于https://github.com/ben-manes/caffeine/wiki/Benchmarks-zh-CN 基准测试通过使用Java microbenchmark ha…
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023