Linux--构建进程池

news2024/9/24 13:21:09

目录

 1.进程池

1.1.我们先完成第一步，创建子进程和信道

1.2. 通过channel控制，发送任务

1.3回收管道和子进程

1.4进行测试

1.5完整代码

 1.进程池

进程池其产生原因主要是为了优化大量任务需要多进程完成时频繁创建和删除进程所带来的资源消耗，以及更好的实现多个进程间的协同。以下是关于进程池的一些关键点：

  1. 组成：进程池技术主要由两部分组成：资源进程和管理进程。资源进程是预先创建好的空闲进程，等待管理进程分发任务（maste向哪个管道写入，就是唤醒哪一个子进程处理任务）。管理进程则负责创建这些资源进程，将工作分配给空闲的资源进程处理，并在工作完成后回收这些资源进程。（父进程要进行后端任务的负载均衡）
  2. 管理：管理进程如何有效地管理资源进程是关键。这涉及到分配任务给资源进程、回收空闲资源进程等操作。管理进程和资源进程之间需要进行交互，这种交互可以通过管道（需要子进程执行一个任务我们就可以派发一个管道，连接一个子进程，执行任务）
  3. 使用场景：当我们需要并行的处理大规模任务时，比如服务器处理大量客户端的任务，进程池是一个很好的选择。它可以避免频繁创建和销毁进程的开销，提高应用的响应速度。
  4. 优化：使用进程池可以避免动态创建和销毁进程的开销，提高应用的性能和稳定性。此外，进程池还可以根据任务的执行情况尽量减少创建的进程数量，最多创建指定个数的进程。

代码实现：

        实现进程池首先我们需要提前准备好一批数量的进程，当一个任务队列被提交到线程池，每个工作进程都会不断从任务队列中取出任务并执行。

1.1.我们先完成第一步，创建子进程和信道

        

        Channel类是来管理一个子进程和与之相关联的管道写端，这个Channel类就是信道。用于一个需要管理多个子进程和它们各自管道写端的程序中。例如，你可能有一个父进程，它创建多个子进程，每个子进程都通过管道与父进程通信。在这种情况下，你可以为每个子进程和它的管道写端创建一个Channel对象，并使用这些对象来管理它们。

class Channel
{
public:
    Channel(int wfd, pid_t id, const std::string &name)
        : _wfd(wfd), _subprocessid(id), _name(name)
    {
    }
    int GetWfd() { return _wfd; }
    pid_t GetProcessId() { return _subprocessid; }
    std::string GetName() { return _name; }
    void CloseChannel()
    {
        close(_wfd);
    }
    void Wait()
    {
        pid_t rid = waitpid(_subprocessid, nullptr, 0);
        if (rid > 0)
        {
            std::cout << "wait " << rid << " success" << std::endl;
        }
    }
    ~Channel()
    {
    }

private:
    int _wfd;//写端fd
    pid_t _subprocessid;//子进程id'
    std::string _name;//一个信道的名称
};

        下面函数的主要逻辑是创建多个管道和相应的子进程，每个子进程都将从它自己的管道中读取数据，而父进程则保留管道的写端以便后续向子进程发送数据。同时，这个函数也维护了一个 Channel 对象的向量（std::vector<Channel>），其中每个 Channel 对象代表一个与特定子进程和管道写端相关联的通道。

        task_t是一个函数指针类型，是为了泛型，将来可以传任意不同的任务交给子进程做。

可以理解为回调函数 task 的使用降低了任务与子进程之间的耦合度。在传统的编程模型中，你可能会为每个子进程编写特定的代码块，这些代码块直接嵌入在创建子进程的函数中。这样做会导致代码的高耦合性，因为每个子进程的行为都紧密地绑定在创建它们的函数中。（关于task的应用见下文）

        dup2(pipefd[0], 0)将管道的读端，重定向到标准输入。意思就是管道的读端变成了标准输入，无需修改代码以处理文件描述符，因为以后任意的子进程去读取任务，都是从标准输入去读取的。

        在子进程中，它关闭了管道的写端，将读端重定向到标准输入，执行给定的回调函数 task，然后关闭读端并退出。

void CreateChannelAndSub(int num, std::vector<Channel> *channels, task_t task)
{
    // BUG? --> fix bug
    for (int i = 0; i < num; i++)
    {
        // 1. 创建管道
        int pipefd[2] = {0};
        int n = pipe(pipefd);
        if (n < 0)
            exit(1);

        // 2. 创建子进程
        pid_t id = fork();
        if (id == 0)
        {
            if (!channels->empty())
            {
                // 第二次之后，开始创建的管道
                for(auto &channel : *channels) channel.CloseChannel();
            }
            // child - read
            close(pipefd[1]);
            dup2(pipefd[0], 0); // 将管道的读端，重定向到标准输入
            task();
            close(pipefd[0]);
            exit(0);
        }

        // 3.构建一个channel名称
        std::string channel_name = "Channel-" + std::to_string(i);
        // 父进程
        close(pipefd[0]);
        // a. 子进程的pid b. 父进程关心的管道的w端
        channels->push_back(Channel(pipefd[1], id, channel_name));
    }
}

提供一个任务文件，接下来让子进程执行任务：

#pragma once

#include <iostream>
#include <ctime>
#include <cstdlib>
#include <sys/types.h>
#include <unistd.h>

#define TaskNum 3

typedef void (*task_t)(); // task_t 函数指针类型

void Print()
{
    std::cout << "I am print task" << std::endl;
}
void DownLoad()
{
    std::cout << "I am a download task" << std::endl;
}
void Flush()
{
    std::cout << "I am a flush task" << std::endl;
}

task_t tasks[TaskNum];

void LoadTask()
{
    srand(time(nullptr) ^ getpid() ^ 17777);
    tasks[0] = Print;
    tasks[1] = DownLoad;
    tasks[2] = Flush;
}

void ExcuteTask(int number)
{
    if (number < 0 || number > 2)
        return;
    tasks[number]();
}

int SelectTask()
{
    return rand() % TaskNum;
}

void work()
{
    while (true)
    {
        int command = 0;
        int n = read(0, &command, sizeof(command));
        if (n == sizeof(int))
        {
            std::cout << "pid is : " << getpid() << " handler task" << std::endl;
            ExcuteTask(command);
        }
        else if (n == 0)
        {
            std::cout << "sub process : " << getpid() << " quit" << std::endl;
            break;
        }
    }
}
  • 初始化阶段：LoadTask()函数被调用，设置tasks函数指针数组以包含所有可用的任务函数，通过索引调用三个具体的任务函数：Print(), DownLoad(), 和 Flush()。
  • 任务选择阶段：SelectTask()函数在需要时用于生成一个随机任务索引。
  • 任务执行阶段：在子进程中，work()函数不断监听标准输入，等待一个任务索引。一旦接收到索引，就调用ExcuteTask()来执行相应的任务。

子进程退出：当子进程从标准输入读取到0时，它知道应该退出循环并结束。

1.2. 通过channel控制，发送任务

int NextChannel(int channelnum)
{
    static int next = 0;
    int channel = next;
    next++;
    next %= channelnum;
    return channel;
}
void SendTaskCommand(Channel &channel, int taskcommand)
{
    write(channel.GetWfd(), &taskcommand, sizeof(taskcommand));
}
void ctrlProcessOnce(std::vector<Channel> &channels)
{
    sleep(1);
    // a. 选择一个任务
    int taskcommand = SelectTask();
    // b. 选择一个信道和进程
    int channel_index = NextChannel(channels.size());
    // c. 发送任务
    SendTaskCommand(channels[channel_index], taskcommand);
    std::cout << std::endl;
    std::cout << "taskcommand: " << taskcommand << " channel: "
              << channels[channel_index].GetName() << " sub process: " << channels[channel_index].GetProcessId() << std::endl;
}
void ctrlProcess(std::vector<Channel> &channels, int times = -1)
{
    if (times > 0)
    {
        while (times--)
        {
            ctrlProcessOnce(channels);
        }
    }
    else
    {
        while (true)
        {
            ctrlProcessOnce(channels);
        }
    }
}
  1.   NextChannel 函数是一个轮询选择器，用于在给定的通道数量（channelnum）中循环选择一个通道索引。它使用了一个静态变量 next 来跟踪上一次选择的索引，并在每次调用时递增这个索引。
  2.  SendTaskCommand 函数用于向指定的 Channel 对象（代表一个与子进程的通信通道）发送一个任务命令（taskcommand）。它通过调用 Channel 对象的 GetWfd 方法获取管道的写端文件描述符，然后使用 write 系统调用来将任务命令写入管道。这样，子进程就可以从管道中读取这个命令并执行相应的任务。
  3.  ctrlProcessOnce 函数模拟了控制进程的一次操作。调用 NextChannel 函数来选择一个通道索引，并通过该索引从 channels 向量中获取一个 Channel 对象。然后，它调用 SendTaskCommand 函数向选定的通道发送任务命令。最后，它打印出相关的信息，包括任务命令、通道名称和子进程的进程ID，以便进行调试和监控。               
  4. ctrlProcess 函数是控制进程的主循环。它接受一个 channels 向量和一个可选的 times 参数。如果 times 大于0，则控制进程会循环执行 ctrlProcessOnce 函数 times 次；如果 times 小于或等于0（默认为-1），则控制进程会无限循环地执行 ctrlProcessOnce 函数

1.3回收管道和子进程

class Channel
{
public:
    Channel(int wfd, pid_t id, const std::string &name)
        : _wfd(wfd), _subprocessid(id), _name(name)
    {
    }
    int GetWfd() { return _wfd; }
    pid_t GetProcessId() { return _subprocessid; }
    std::string GetName() { return _name; }
    void CloseChannel()
    {
        close(_wfd);
    }
    void Wait()
    {
        pid_t rid = waitpid(_subprocessid, nullptr, 0);
        if (rid > 0)
        {
            std::cout << "wait " << rid << " success" << std::endl;
        }
    }
    ~Channel()
    {
    }

private:
    int _wfd;//写端fd
    pid_t _subprocessid;//子进程id'
    std::string _name;//一个信道的名称
};

void CleanUpChannel(std::vector<Channel> &channels)
{

    for (auto &channel : channels)
    {
        channel.CloseChannel();
    }
    for (auto &channel : channels)
    {
        channel.Wait();
    }
}

a. 关闭所有的写端 b. 回收子进程

注意：一定是先关闭全部读端，然后统一读端，而不能关一个，等待一个。

在执行子进程创建逻辑的时候，是存在bug的。

我们在创建第一个信道的时候是没有什么问题的：

接着来看，我们创建第二个信道会发生什么：fd[4]的指向被第二个信道的子进程继承了，那么第一个管道的写端就个fd指向了，这就是坑

如果继续创建更多的信道，那么这种情况会一直累积，只有最后一个文件只有一个写端。如果我们是关一个等待一个，那么第一个信道，只会关闭一个读端，但还有其它的读端，这就会发生进程阻塞，导致管道文件一直在等待读取，无法被释放；如果统一的关闭读端，那么当关闭到最后一个信道的时候，最后一个信道读端只有一个，管道文件会被释放，然后就会递归式的逆向关闭其它信道的所有读端，最后将所有的管道文件释放，父进程只需要一 一等待，就能回收所有子进程了。

1.4进行测试

子进程执行任务成功，父进程回收子进程成功。

1.5完整代码

Task.hpp

#pragma once

#include <iostream>
#include <ctime>
#include <cstdlib>
#include <sys/types.h>
#include <unistd.h>

#define TaskNum 3

typedef void (*task_t)(); // task_t 函数指针类型

void Print()
{
    std::cout << "I am print task" << std::endl;
}
void DownLoad()
{
    std::cout << "I am a download task" << std::endl;
}
void Flush()
{
    std::cout << "I am a flush task" << std::endl;
}

task_t tasks[TaskNum];

void LoadTask()
{
    srand(time(nullptr) ^ getpid() ^ 17777);
    tasks[0] = Print;
    tasks[1] = DownLoad;
    tasks[2] = Flush;
}

void ExcuteTask(int number)
{
    if (number < 0 || number > 2)
        return;
    tasks[number]();
}

int SelectTask()
{
    return rand() % TaskNum;
}

void work()
{
    while (true)
    {
        int command = 0;
        int n = read(0, &command, sizeof(command));
        if (n == sizeof(int))
        {
            std::cout << "pid is : " << getpid() << " handler task" << std::endl;
            ExcuteTask(command);
        }
        else if (n == 0)
        {
            std::cout << "sub process : " << getpid() << " quit" << std::endl;
            break;
        }
    }
}

test.cc

#include <iostream>
#include <string>
#include <vector>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include "Task.hpp"

class Channel
{
public:
    Channel(int wfd, pid_t id, const std::string &name)
        : _wfd(wfd), _subprocessid(id), _name(name)
    {
    }
    int GetWfd() { return _wfd; }
    pid_t GetProcessId() { return _subprocessid; }
    std::string GetName() { return _name; }
    void CloseChannel()
    {
        close(_wfd);
    }
    void Wait()
    {
        pid_t rid = waitpid(_subprocessid, nullptr, 0);
        if (rid > 0)
        {
            std::cout << "wait " << rid << " success" << std::endl;
        }
    }
    ~Channel()
    {
    }

private:
    int _wfd;
    pid_t _subprocessid;
    std::string _name;
};

//  task_t task: 回调函数
void CreateChannelAndSub(int num, std::vector<Channel> *channels, task_t task)
{
    // BUG? --> fix bug
    for (int i = 0; i < num; i++)
    {
        // 1. 创建管道
        int pipefd[2] = {0};
        int n = pipe(pipefd);
        if (n < 0)
            exit(1);

        // 2. 创建子进程
        pid_t id = fork();
        if (id == 0)
        {
            if (!channels->empty())
            {
                // 第二次之后，开始创建的管道
                for(auto &channel : *channels) channel.CloseChannel();
            }
            // child - read
            close(pipefd[1]);
            dup2(pipefd[0], 0); // 将管道的读端，重定向到标准输入
            task();
            close(pipefd[0]);
            exit(0);
        }

        // 3.构建一个channel名称
        std::string channel_name = "Channel-" + std::to_string(i);
        // 父进程
        close(pipefd[0]);
        // a. 子进程的pid b. 父进程关心的管道的w端
        channels->push_back(Channel(pipefd[1], id, channel_name));
    }
}

int NextChannel(int channelnum)
{
    static int next = 0;
    int channel = next;
    next++;
    next %= channelnum;
    return channel;
}

void SendTaskCommand(Channel &channel, int taskcommand)
{
    write(channel.GetWfd(), &taskcommand, sizeof(taskcommand));
}
void ctrlProcessOnce(std::vector<Channel> &channels)
{
    sleep(1);
    // a. 选择一个任务
    int taskcommand = SelectTask();
    // b. 选择一个信道和进程
    int channel_index = NextChannel(channels.size());
    // c. 发送任务
    SendTaskCommand(channels[channel_index], taskcommand);
    std::cout << std::endl;
    std::cout << "taskcommand: " << taskcommand << " channel: "
              << channels[channel_index].GetName() << " sub process: " << channels[channel_index].GetProcessId() << std::endl;
}
void ctrlProcess(std::vector<Channel> &channels, int times = -1)
{
    if (times > 0)
    {
        while (times--)
        {
            ctrlProcessOnce(channels);
        }
    }
    else
    {
        while (true)
        {
            ctrlProcessOnce(channels);
        }
    }
}

void CleanUpChannel(std::vector<Channel> &channels)
{

    for (auto &channel : channels)
    {
        channel.CloseChannel();
        
    }
    for (auto &channel : channels)
    {
        
        channel.Wait();
    }
}

int main(int argc, char *argv[])
{
    if (argc != 2)
    {
        std::cerr << "Usage: " << argv[0] << " processnum" << std::endl;
        return 1;
    }
    int num = std::stoi(argv[1]);
    LoadTask();

    std::vector<Channel> channels;
    // 1. 创建信道和子进程
    CreateChannelAndSub(num, &channels, work);

    // 2. 通过channel控制子进程
    ctrlProcess(channels, 10);

    // 3. 回收管道和子进程. a. 关闭所有的写端 b. 回收子进程
    CleanUpChannel(channels);

    // sleep(100);
    return 0;
}#include <iostream>
#include <string>
#include <vector>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include "Task.hpp"

class Channel
{
public:
    Channel(int wfd, pid_t id, const std::string &name)
        : _wfd(wfd), _subprocessid(id), _name(name)
    {
    }
    int GetWfd() { return _wfd; }
    pid_t GetProcessId() { return _subprocessid; }
    std::string GetName() { return _name; }
    void CloseChannel()
    {
        close(_wfd);
    }
    void Wait()
    {
        pid_t rid = waitpid(_subprocessid, nullptr, 0);
        if (rid > 0)
        {
            std::cout << "wait " << rid << " success" << std::endl;
        }
    }
    ~Channel()
    {
    }

private:
    int _wfd;
    pid_t _subprocessid;
    std::string _name;
};

//  task_t task: 回调函数
void CreateChannelAndSub(int num, std::vector<Channel> *channels, task_t task)
{
    // BUG? --> fix bug
    for (int i = 0; i < num; i++)
    {
        // 1. 创建管道
        int pipefd[2] = {0};
        int n = pipe(pipefd);
        if (n < 0)
            exit(1);

        // 2. 创建子进程
        pid_t id = fork();
        if (id == 0)
        {
            if (!channels->empty())
            {
                // 第二次之后，开始创建的管道
                for(auto &channel : *channels) channel.CloseChannel();
            }
            // child - read
            close(pipefd[1]);
            dup2(pipefd[0], 0); // 将管道的读端，重定向到标准输入
            task();
            close(pipefd[0]);
            exit(0);
        }

        // 3.构建一个channel名称
        std::string channel_name = "Channel-" + std::to_string(i);
        // 父进程
        close(pipefd[0]);
        // a. 子进程的pid b. 父进程关心的管道的w端
        channels->push_back(Channel(pipefd[1], id, channel_name));
    }
}

int NextChannel(int channelnum)
{
    static int next = 0;
    int channel = next;
    next++;
    next %= channelnum;
    return channel;
}

void SendTaskCommand(Channel &channel, int taskcommand)
{
    write(channel.GetWfd(), &taskcommand, sizeof(taskcommand));
}
void ctrlProcessOnce(std::vector<Channel> &channels)
{
    sleep(1);
    // a. 选择一个任务
    int taskcommand = SelectTask();
    // b. 选择一个信道和进程
    int channel_index = NextChannel(channels.size());
    // c. 发送任务
    SendTaskCommand(channels[channel_index], taskcommand);
    std::cout << std::endl;
    std::cout << "taskcommand: " << taskcommand << " channel: "
              << channels[channel_index].GetName() << " sub process: " << channels[channel_index].GetProcessId() << std::endl;
}
void ctrlProcess(std::vector<Channel> &channels, int times = -1)
{
    if (times > 0)
    {
        while (times--)
        {
            ctrlProcessOnce(channels);
        }
    }
    else
    {
        while (true)
        {
            ctrlProcessOnce(channels);
        }
    }
}

void CleanUpChannel(std::vector<Channel> &channels)
{

    for (auto &channel : channels)
    {
        channel.CloseChannel();
        
    }
    for (auto &channel : channels)
    {
        
        channel.Wait();
    }
}

int main(int argc, char *argv[])
{
    if (argc != 2)
    {
        std::cerr << "Usage: " << argv[0] << " processnum" << std::endl;
        return 1;
    }
    int num = std::stoi(argv[1]);
    LoadTask();

    std::vector<Channel> channels;
    // 1. 创建信道和子进程
    CreateChannelAndSub(num, &channels, work);

    // 2. 通过channel控制子进程
    ctrlProcess(channels, 10);

    // 3. 回收管道和子进程. a. 关闭所有的写端 b. 回收子进程
    CleanUpChannel(channels);

    // sleep(100);
    return 0;
}

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

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

相关文章

windows 执行node报错 800A1391

windows 执行node报错 800A1391

在项目下执行node -v的时候&#xff0c;抛了这个错误&#xff0c;一开始没发现有啥问题 现在一看&#xff0c;这个报错里的node怎么是个文件... 出现这个问题&#xff0c;是因为项目下&#xff0c;有个同名的文件叫node.js&#xff0c;搞得windows一时不知道是想打开node.js文…
阅读更多...
gem5模拟器入门（一）——环境配置

gem5模拟器入门（一）——环境配置

什么是gem5&#xff1f; gem5是一个模块化的离散事件驱动的计算机系统模拟器平台。这意味着&#xff1a; GEM5 的组件可以轻松重新排列、参数化、扩展或更换&#xff0c;以满足您的需求。它将时间的流逝模拟为一系列离散事件。它的预期用途是以各种方式模拟一个或多个计算机系…
阅读更多...
数码论坛|基于SprinBoot+vue的数码论坛系统(源码+数据库+文档)

数码论坛|基于SprinBoot+vue的数码论坛系统(源码+数据库+文档)

数码论坛系统 目录 基于SprinBootvue的数码论坛系统 一、前言 二、系统设计 三、系统功能设计 1系统功能模块 2 管理员功能模块 3 用户后台管理模块 四、数据库设计 五、核心代码 六、论文参考 七、最新计算机毕设选题推荐 八、源码获取&#xff1a; 博主介绍&am…
阅读更多...
STM32-11-电容触摸按键

STM32-11-电容触摸按键

STM32-01-认识单片机 STM32-02-基础知识 STM32-03-HAL库 STM32-04-时钟树 STM32-05-SYSTEM文件夹 STM32-06-GPIO STM32-07-外部中断 STM32-08-串口 STM32-09-IWDG和WWDG STM32-10-定时器 STM32电容触摸按键 电容触摸按键原理&#xff1a; 无手指触摸&#xff1a;上电时&…
阅读更多...
DSP开发入门

DSP开发入门

视频&#xff1a; 创龙TI 最新DSP CPU核心架构 C66x 以及 KeyStone I 架构 DSP TMS320C6655/57以及TMS320C6678视频教程全集_哔哩哔哩_bilibili 2024年硬汉科技手把手教您学DSP28335视频教程持续更新中_哔哩哔哩_bilibili DSP芯片介绍 DSP选型 TI的DSP 分为三大系列&#…
阅读更多...
基于Android的家庭理财APP的设计与实现(论文+源码)_kaic

基于Android的家庭理财APP的设计与实现(论文+源码)_kaic

摘 要 随着我国居民收入和生活水平的提高&#xff0c;家庭理财成为人们热议的焦点问题。在需求分析阶段&#xff0c;系统从用户的实际需求出发&#xff0c;确定了用户账户管理、记账、数据分析和提醒功能等几个核心需求。用户账户管理包括用户注册、登录和密码找回等基本操作…
阅读更多...
游戏私域运营指南 | 降低买量成本，精细化游戏私域运营看这篇就懂了！

游戏私域运营指南 | 降低买量成本，精细化游戏私域运营看这篇就懂了！

私域是什么&#xff1f;这个概念在零售行业已经盛行多年&#xff0c;但在游戏行业提及得并不多&#xff0c;从业者们可能更熟悉的 近似概念是“社区运营”。 那么首先&#xff0c;让我们明确定义&#xff1a;相对于社交媒体、搜索引擎、电商平台等需要通过付费投放来进行高效流…
阅读更多...
webshell工具-冰蝎流量特征和加密方式

webshell工具-冰蝎流量特征和加密方式

一、冰蝎原理 1.1 简介 冰蝎是一款基于Java开发的动态加密通信流量的新型Webshell客户端&#xff0c;由于通信流量被加密&#xff0c;传统的WAF、IDS 设备难以检测&#xff0c;给威胁狩猎带来较大挑战。冰蝎其最大特点就是对交互流量进行对称加密&#xff0c;且加密密钥是由随…
阅读更多...
【前端常见面试题整理】

【前端常见面试题整理】

开放性的题目 自我介绍 突出学习能力 我想换工作的主要原因是 介绍项目 平时是如何学习前端开发的 主要就是两个途径&#xff0c;一个是查阅官方文档&#xff0c;然后就是在网上查找技术资料或者视频去学习。平时没事的时候也会看看github&#xff0c;同时关注一些社区和IT网…
阅读更多...
浅说线性DP（上）

浅说线性DP（上）

前言 在说线性dp之前&#xff0c;我们先来聊一聊动态规划是啥&#xff1f; 动态规划到底是啥&#xff1f; 动态规划是普及组内容中最难的一个部分&#xff0c;也是每年几乎必考的内容。它对思维的要求极高&#xff0c;它和图论、数据结构不同的地方在于它没有一个标准的数学…
阅读更多...
Rust最新版安装(v1.78.0+)

Rust最新版安装(v1.78.0+)

系统&#xff1a;Windows 11 专业版 23H2rustc&#xff1a;1.78.0 配置环境变量和设置配置文件 新建文件夹“C:\Rust\Rustup”和“C:\Rust\Cargo”。【以管理员身份运行】打开CMD 设置系统环境变量&#xff0c;如下设置RUSTUP_DIST_SERVER&#xff0c;其余同理 C:\Windows\S…
阅读更多...
中国教育 AI 产品正在成为百万美国学生的辅导老师；李飞飞：大模型不存在主观感觉能力丨 RTE 开发者日报 Vol.213

中国教育 AI 产品正在成为百万美国学生的辅导老师；李飞飞：大模型不存在主观感觉能力丨 RTE 开发者日报 Vol.213

开发者朋友们大家好&#xff1a; 这里是 「RTE 开发者日报」 &#xff0c;每天和大家一起看新闻、聊八卦。 我们的社区编辑团队会整理分享 RTE&#xff08;Real-Time Engagement&#xff09; 领域内「有话题的新闻」、「有态度的观点」、「有意思的数据」、「有思考的文章」、…
阅读更多...
编程5年的老哥说：我代码里从来不用锁，谁爱...

编程5年的老哥说：我代码里从来不用锁，谁爱...

技多不压身&#xff01; 大家好&#xff0c;我是 javapub。 今天一个朋友找我吐槽&#xff0c;说自己平时在工作中几乎用不到需要上锁的场景&#xff0c;就算有也只是并发很小、或者直接从有业务设计上就规避掉了。但一到面试&#xff0c;都是各种锁题&#xff0c;很头疼。 面…
阅读更多...
YYDS！哈工大博士PyTorch笔记火了！！

YYDS！哈工大博士PyTorch笔记火了！！

Pytorch是目前常用的深度学习框架之一&#xff0c;它凭借着对初学者的友好性、灵活性&#xff0c;发展迅猛&#xff0c;它深受学生党的喜爱&#xff0c;我本人也是使用的Pytorch框架。 比起 TF 的框架环境配置不兼容&#xff0c;和 Keras 由于高度封装造成的不灵活&#xff0c…
阅读更多...
三、Ollama导入大模型（.Net8+SemanticKernel+Ollama）本地运行自己的大模型

三、Ollama导入大模型（.Net8+SemanticKernel+Ollama）本地运行自己的大模型

Ollama导入大模型 一、导入Ollama大模型1、使用run命令2、使用Modelfile方式 二、导入自定义大模型&#xff08;Ollama官网以外的大模型&#xff09;三、使用OpenWebUI导入大模型 Ollama可以导入官方提供的大模型&#xff0c;也可以导入huggingface上的自定义大模型&#xff08…
阅读更多...
以太坊现货ETF获批：引发ETH价格暴涨，市场热议达到高潮

以太坊现货ETF获批：引发ETH价格暴涨，市场热议达到高潮

2024年5月24日&#xff0c;北京时间&#xff0c;以太坊现货ETF正式获得美国证券交易委员会&#xff08;SEC&#xff09;的批准&#xff0c;成为继比特币之后&#xff0c;美国主权政府承认的又一加密货币基金产品。这一意外的利好消息引发了加密货币市场的狂欢&#xff0c;以太坊…
阅读更多...
东软的第三个研发基地，为什么选择了武汉？

东软的第三个研发基地，为什么选择了武汉？

继沈阳、大连之后&#xff0c;东软集团在国内打造的第三个研发基地——武汉东软软件园&#xff0c;于2024年5月25日正式开园。 “占地面积158亩、建筑面积14万余平方米的武汉东软软件园&#xff0c;从开工到竣工仅仅用了18个月的时间。这样的建设速度&#xff0c;充分体现了武汉…
阅读更多...
香橙派Kunpeng Pro性能测评：高效能小型服务器开发板的全面体验

香橙派Kunpeng Pro性能测评：高效能小型服务器开发板的全面体验

香橙派 Kunpeng Pro 是一款面向开发者和教育市场的高性能单板计算机&#xff0c;其搭载了鲲鹏处理器&#xff0c;可提供 8TOPS INT8 计算能力&#xff0c;提供了 8GB 和 16GB 两种内存版本&#xff0c;开发板结合了鲲鹏全栈根技术&#xff0c;全面使能高校计算机系统教学和原生…
阅读更多...
3D Web轻量化平台HOOPS Web Platform在数字工厂中的应用实例

3D Web轻量化平台HOOPS Web Platform在数字工厂中的应用实例

今天我们来聊聊HOOPS工具对大型数据的处理和可视化管理。这里是一个数字工厂的仪表盘展示&#xff0c;您可以在仪表盘上看到包括工厂的能源消耗、计划产量等数据信息&#xff0c;以及各种制造机器的生产量。 HOOPS中文网http://techsoft3d.evget.com/ 我们的HOOPS工具&#xf…
阅读更多...
window.location.search取不到值

window.location.search取不到值

window.location.search window.location.search没有值的原因&#xff1a; URL中使用了 hash &#xff08;指URL中带有#符号&#xff09;,导致URL后面携带的参数被location.hash截取走了&#xff0c;你再使用window.location.search得到的就是空值 打印 window.location 其实…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023