进程间的通信--管道

在这里插入图片描述

文章目录

  • 一、进程通信的介绍
    • 1.1进程间为什么需要通信
    • 1.2进程如何通信
  • 二、管道
    • 2.1匿名管道
      • 2.1.1文件描述符理解管道
      • 2.1.2接口使用
      • 2.1.3管道的4种情况
      • 2.1.4管道的五种特征
    • 2.2管道的使用场景
      • 2.2.1命令行中的管道
      • 2.2.2进程池
    • 2.命名管道
      • 2.1.1原理
      • 2.2.2接口
      • 2.2.3代码实例

一、进程通信的介绍

1.1进程间为什么需要通信

进程之间需要协同。 例如,学校里面的各个管理层之间都是互相联系的,不能只是纵向管理。正是因为进程之间需要协同,协同的前提条件是进程之间需要通信,数据是有类别的,有的数据是通知就绪的,有些数据是单纯所传递数据,有的是控制相关的数据。

事实:进程是具有独立性的,进程=内核数据结构+进程的代码和数据

进程通信的目的:

  • 数据传输:一个进程需要将它的数据发送给另一个进程
  • 资源共享:多个进程之间共享同样的资源。
  • 通知事件:一个进程需要向另一个或一组进程发送消息,通知它(它们)发生了某种事件(如进程终止时要通知父进程)。
  • 进程控制:有些进程希望完全控制另一个进程的执行(如Debug进程),此时控制进程希望能够拦截另一个进程的所有陷入和异常,并能够及时知道它的状态改变。

1.2进程如何通信

进程之间的通信,成本可能稍微高一些:进程是具有独立性的,任何一个进程开辟的资源,另一个进程是看不到的。之前在聊父子进程的时候,父进程的数据被子进程继承下去,这不属于通信,能继承但是不是一直继承,能传递信息和一直能传递信息是不一样的。

进程间的通信的前提:先让不同的进程看到同一份(操作系统)资源(“一段内存”)。两个进程之间是独立的,要实现通信,需要一个工具,即操作系统,使得两个进程之间有一片相同的内存。操作系统这样做的原因是用户决定的。
如何让操作系统创建资源:

  1. 一定是,某一个进程先需要通信,让OS创建一个共享资源
  2. OS必须提供很多的系统调用,让进程以系统调用的方式申请系统的资源
    OS创建的共享资源的不同、系统调用接口的不同决定进程间通信会有不同的种类。

在这里插入图片描述

二、管道

2.1匿名管道

2.1.1文件描述符理解管道

在这里插入图片描述

管道本质上是一种内存级文件,它不用往磁盘上进行刷新
首先父进程以读写方式分两次打开一个文件,分两次的原因是为了获得两个 struct file 对象,这样对一个文件就有两个读写指针,让读写操作使用各自独立的指针,这样读写之间就不会相互影响。读写指针记录了当前文件读取或写入的位置,一个 struct file 中只有一个读写指针,在向文件写入(或读取)的时候,读写指针会发生移动,然后再去读取(写入),此时读写指针已经不再最初的位置,无法将刚写入的内容读取上来,因此这里需要分两次以不同的方式打开同一个文件。接着创建子进程,子进程会继承父进程中打开的文件,也就是继承父进程的文件描述符表,此时父子进程就会共享同一个文件资源,子进程可以通过4号文件描述符向文件中进行写入,父进程就可以通过3号文件描述符从文件中进程读取,此时父子进程就实现了数据传输,也就是通信。父子进程看到同一段内存缓冲区,这里我们称之为管道文件。管道只允许单向通信,因为简单。

为什么父子进程会向同一个显示器终端打印数据?
因为对应的子进程会继承父进程对应的文件描述符表,进而会指向同一个文件,也就意味着父进程往一个文件里面打,子进程也会往一个文件里面打,都会写到同样的一个缓冲区里,操作系统就会刷新到同一个显示器。


进程会默认打开三个标准输入标准输出:0,1,2…如何默认打开0,1,2?
所有的,命令都是bash的子进程,只要bash打开了,默认的子进程就都打开了。


为什么子进程主动clos(0/1/2),不影响父进程继续使用显示器文件?
内存级引用计数会--,当内存级引用计数减到0,就释放文件资源。


父子进程关闭不需要的文件描述符,为什么之前需要打开?
为了让子进程继承下去。可以不关闭,建议关了,防止万一误写了。


为什么管道是单向通信的?
方式简单,减少开发成本,只让它进行单向通信,任何一个文件刷新到缓冲区里,再把数据刷新到文件里,这个过程本身就是单向的。
生活中我们见到的简单管道都是单向的,比如自来水管道,一个入口一个出口,符合管道的特点。

2.1.2接口使用

可以使用pipe来创建一个无名管道,参数不需要文件路径和文件名

int pipe(int pipefd[2]);

fd:文件描述符数组,其中fd[0]表示读端, fd[1]表示写端
返回值:成功返回0,失败返回错误代码

在这里插入图片描述

测试管道接口:

#include<iostream>
#include<cerrno>
#include<cstring>
#include<unistd.h>

int main()
{
    int pipefd[2];      // 用于存储管道的两个文件描述符
    int n=pipe(pipefd);    // 创建管道,返回值为0表示成功,-1表示失败
    if(n!=0)           //如果 pipe() 函数返回值不为0,表示管道创建失败
    {
        std::cerr<<"errno: "<<errno<<": "<<"errstring: "<<strerror(errno)<<std::endl;
        return 1;
    }

    std::cout<<"pipefd[0]"<<",pipefd[1]: "<<pipefd[1]<<std::endl;
     //如果管道创建成功,使用 std::cout 打印管道的两个文件描述符 pipefd[0] 和 pipefd[1] 的值
    return 0;
}

在这里插入图片描述

上述代码的主要作用是演示如何在C++中使用 pipe() 函数创建管道,并进行简单的错误处理和输出操作。

pipefd[0]->0->管道文件R(读)端pipefd[1]->1->管道文件W(写)端


上面我们创建好管道,接下来创建子进程

在这里插入图片描述

让子进程能和父进程进行通信:

#include<iostream>
#include<cerrno>
#include<cstring>
#include<unistd.h>
#include<sys/wait.h>
#include<sys/types.h>
#include<string>

const int size=1024;

std::string getOtherMessage()
{
    static int cnt=0;
    std::string messageid=std::to_string(cnt);
    cnt++;
    pid_t self_id=getpid();
    std::string stringpid=std::to_string(self_id);

    std::string message="messageid: ";
    message+=messageid;
    message+="my pid is: ";
    message+=stringpid;

    return message;
}

//子进程进行写入
void subProcessWrite(int wfd)
{
    std::string message="father,I am your son process!";
    while(true)
    {
        std::string info=message+getOtherMessage();  //子进程发送给父进程的消息
        write(wfd,info.c_str(),info.size()); //写入管道没有写入\0,没有必要写进去
        sleep(1);
    }
}


//父进程进行读取
void fatherProcessRead(int rfd)
{
    char inbuffer[size];
    while(true)
    {
        ssize_t n=read(rfd,inbuffer,sizeof(inbuffer)-1);
        if(n>0)
        {
            inbuffer[n]=0;  //==\0
            std::cout<<"father get message: "<<inbuffer<<std::endl;
        }
    }
}

int main()
{
    int pipefd[2];
    int n=pipe(pipefd);
    if(n!=0)
    {
        std::cerr<<"errno: "<<errno<<": "<<"errstring: "<<strerror(errno)<<std::endl;
        return 1;
    }

    std::cout<<"pipefd[0]"<<",pipefd[1]: "<<pipefd[1]<<std::endl;
    sleep(1);

    //创建子进程
    pid_t id=fork();
    if(id==0)
    {   
        std::cout<<"子进程关闭不需要的fd,准备发消息"<<std::endl;
        sleep(1);
        //子进程 write
        //关闭不需要的fd
        close(pipefd[0]);
        subProcessWrite(pipefd[1]);
        close(pipefd[1]);
        exit(0);
    }

    std::cout<<"父进程关闭不需要的fd,准备收消息"<<std::endl;
    sleep(1);
    //父进程 read
    //关闭不需要的fd
    close(pipefd[1]);
    fatherProcessRead(pipefd[0]);
    close(pipefd[0]);
    
    pid_t rid=waitpid(id,nullptr,0);
    if(rid>0)
    {
        std::cout<<"wait child process done"<<std::endl;
    }
    return 0;
}

在这里插入图片描述

getOtherMessage()函数生成一个带有进程ID信息的消息字符串,用于子进程向父进程发送消息。
subProcessWrite(int wfd)函数用于子进程,它不断地生成消息并写入管道 (wfd) 中,每隔一秒发送一次消息
fatherProcessRead(int rfd)函数用于父进程,它不断地从管道 (rfd) 中读取消息并输出到控制台

子进程关闭不需要的管道读取端 (pipefd[0]),调用 subProcessWrite() 发送消息,然后关闭写入端 (pipefd[1])。
父进程关闭不需要的管道写入端 (pipefd[1]),调用 fatherProcessRead() 接收消息,然后关闭读取端 (pipefd[0])。

2.1.3管道的4种情况

  1. 如果管道是空的,并且写端文件描述符没有关闭,读取条件不具备,读进程(父进程)会被阻塞,自动等待读取条件具备(写入进程再重新写入)。
    在这里插入图片描述
    sleep(1)时间内,管道内部没有数据,父进程就在阻塞等待。

  2. 如果管道被写满了,读端不进行读写但是没有关闭,此时写进程会被阻塞(管道被写满,即写条件不具备),直到写条件具备(读取数据)。

  3. 管道一直在读并且写端关闭了fd,读端会读到0,表示读到了文件结尾。

//子进程进行写入
void subProcessWrite(int wfd)
{
    std::string message="father,I am your son process!";
    int pipesize=0;
    char c='A';
    while(true)
    {
        write(wfd,&c,1);
        std::cout << "pipesize: " << ++pipesize << " write charator is : "<< c++ << std::endl;
        if(c=='G') break;
        sleep(1);
    }
    std::cout<<"child quit..."<<std::endl;
}


//父进程进行读取
void fatherProcessRead(int rfd)
{
    char inbuffer[size];
    while(true)
    {
        ssize_t n=read(rfd,inbuffer,sizeof(inbuffer)-1);
        if(n>0)
        {
            inbuffer[n]=0;  //==\0
            std::cout<<"father get message: "<<inbuffer<<std::endl;
        }
        else if(n==0)
        {
            // 如果read的返回值是0,表示写端直接关闭了,我们读到了文件的结尾
            std::cout << "client quit, father get return val: " << n << " father quit too!" << std::endl;
            break;
        }
        else if(n < 0)
        {
            std::cerr << "read error" << std::endl;
            break;
        }
    }
}

在这里插入图片描述

  1. 读端fd直接关闭,写端fd一直进行写入,这个管道称之为坏的管道,操作系统会杀掉对应的进程,属于异常情况,操作系统会给目标发送信号(13号:SIGPIPE)。写端进程会被操作系统直接使用13号信号关掉,相当于进程出现了异常。

2.1.4管道的五种特征

  1. 匿名管道:只能用来进行具有血缘关系的进程之间通信(常用于父子进程),因为子进程是对父进程的写时拷贝,不能用于毫不相关的两个进程。
  2. 管道内部自带进程之间同步机制,同步:多执行流执行代码的时候具有明显的顺序性。在上述代码中,子进程写一个,父进程读一个。
  3. 文件的声明周期是随进程的
  4. 管道文件在通信的时候,是面向字节流的。写的次数和读取的次数不是一一匹配的
  5. 管道的通信模式是一种特殊的半双工
    在这里插入图片描述

2.2管道的使用场景

2.2.1命令行中的管道

管道 | 在这里用于串联命令,实现对进程信息的过滤、筛选和显示,使得可以实时监视和管理特定的进程活动。

2.2.2进程池

当前有一个父进程(master),提前创建好几个子进程(子进程A、子进程B、子进程C、子进程D),每一个子进程还对应一个管道,用于和父进程进行通信。当父进程需要某一个子进程的时候,只需要将信息传入对应管道的写端,然后对应的子进程从管道读端读取数据。像这种提前创建好多个子进程,我们称之为进程池,这样可以大大减少创建进程的成本,只需要把任务交付给对应的子进程。

在这里插入图片描述

如果管道里面没有数据,当前对应的worker进程就在阻塞等待,直到任务的到来。

管道里一旦有数据,对应的子进程就被系统唤醒来处理任务。

对于父进程的任务,要进行后端任务划分的负载均衡。

代码实现:

对信道的一个一个管理转化成对vector的增删查改,将父进程的文件描述符为_wfd,写给对应的子程序为_subprocessid

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

// master
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;
};

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));
    }
}

// 0 1 2 3 4 channelnum
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)
{
    // int num = channels.size() -1;
    // while(num >= 0)
    // {
    //     channels[num].CloseChannel();
    //     channels[num--].Wait();
    // }

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

// ./processpool 5
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, work1);

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

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

    // sleep(100);
    return 0;
}

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;
        }
    }
}

void work1()
{
    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;
        }
    }
}

void work2()
{
    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;
        }
    }
}

2.命名管道

2.1.1原理

如何保证两个毫不相连的两个进程打开同一个文件?每一个文件都有文件路劲(唯一性路劲),两个进程使用同一个文件路劲。
在这里插入图片描述

磁盘中的文件是一个特殊文件,经过路劲标识,命名管道本质上就是系统中的一个内存级文件,它和匿名管道一样,不会向磁盘中刷新,但是它有文件名。路径+文件名,唯一标识了一个命名管道

2.2.2接口

认识mkfifo

在这里插入图片描述

创建一个管道:

mkfifo 文件名

2.2.3代码实例

namedPipe.hpp:

#pragma once

#include <iostream>
#include <cstdio>
#include <cerrno>
#include <string>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

const std::string comm_path = "./myfifo";
#define DefaultFd -1
#define Creater 1
#define User 2
#define Read O_RDONLY
#define Write O_WRONLY
#define BaseSize 4096

class NamePiped
{
private:
    bool OpenNamedPipe(int mode)
    {
        _fd = open(_fifo_path.c_str(), mode);
        if (_fd < 0)
            return false;
        return true;
    }

public:
    NamePiped(const std::string &path, int who)
        : _fifo_path(path), _id(who), _fd(DefaultFd)
    {
        if (_id == Creater)
        {
            int res = mkfifo(_fifo_path.c_str(), 0666);
            if (res != 0)
            {
                perror("mkfifo");
            }
            std::cout << "creater create named pipe" << std::endl;
        }
    }
    bool OpenForRead()
    {
        return OpenNamedPipe(Read);
    }
    bool OpenForWrite()
    {
        return OpenNamedPipe(Write);
    }
    // const &: const std::string &XXX
    // *      : std::string *
    // &      : std::string & 
    int ReadNamedPipe(std::string *out)
    {
        char buffer[BaseSize];
        int n = read(_fd, buffer, sizeof(buffer));
        if(n > 0)
        {
            buffer[n] = 0;
            *out = buffer;
        }
        return n;
    }
    int WriteNamedPipe(const std::string &in)
    {
        return write(_fd, in.c_str(), in.size());
    }
    ~NamePiped()
    {
        if (_id == Creater)
        {
            int res = unlink(_fifo_path.c_str());
            if (res != 0)
            {
                perror("unlink");
            }
            std::cout << "creater free named pipe" << std::endl;
        }
        if(_fd != DefaultFd) close(_fd);
    }

private:
    const std::string _fifo_path;
    int _id;
    int _fd;
};

client.cc:

#include "namedPipe.hpp"

// write
int main()
{
    NamePiped fifo(comm_path, User);
    if (fifo.OpenForWrite())
    {
        std::cout << "client open namd pipe done" << std::endl;
        while (true)
        {
            std::cout << "Please Enter> ";
            std::string message;
            std::getline(std::cin, message);
            fifo.WriteNamedPipe(message);
        }
    }

    return 0;
}

server.cc:

#include "namedPipe.hpp"

// server read: 管理命名管道的整个生命周期
int main()
{
    NamePiped fifo(comm_path, Creater);
    // 对于读端而言,如果我们打开文件,但是写还没来,我会阻塞在open调用中,直到对方打开
    // 进程同步
    if (fifo.OpenForRead())
    {
        std::cout << "server open named pipe done" << std::endl;

        sleep(3);
        while (true)
        {
            std::string message;
            int n = fifo.ReadNamedPipe(&message);
            if (n > 0)
            {
                std::cout << "Client Say> " << message << std::endl;
            }
            else if(n == 0)
            {
                std::cout << "Client quit, Server Too!" << std::endl;
                break;
            }
            else
            {
                std::cout << "fifo.ReadNamedPipe Error" << std::endl;
                break;
            }
        }
    }

    return 0;
}

运行结果:

在这里插入图片描述


在这里插入图片描述

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

如若内容造成侵权/违法违规/事实不符,请联系我们进行投诉反馈qq邮箱809451989@qq.com,一经查实,立即删除!

相关文章

C++初阶:类与对象(一)

✨✨所属专栏&#xff1a;C✨✨ ✨✨作者主页&#xff1a;嶔某✨✨ 类的定义 定义格式 • class为定义类的关键字&#xff0c;后面跟类的名字&#xff0c;{}中为类的主体&#xff0c;注意类定义结束时后⾯分号不能省略。类体中内容称为类的成员&#xff1b;类中的变量称为类的…

设计模式之职责链模式

1. 职责链模式&#xff08;Chain of Responsibility Pattern&#xff09; 在职责链模式中&#xff0c;多个处理器依次处理同一个请求。一个请求先经过 A 处理器处理&#xff0c;然后再把请求传递给 B 处理器&#xff0c;B处理器处理完后再传递给 C 处理器&#xff0c;以此类推&…

【Android组件】封装加载弹框

&#x1f4d6;封装加载弹框 ✅1. 构造LoadingDialog✅2. 调用LoadingDialog 效果&#xff1a; ✅1. 构造LoadingDialog 构造LoadingDialog类涉及到设计模式中的建造者模式&#xff0c;进行链式调用&#xff0c;注重的是构建的过程&#xff0c;设置需要的属性。 步骤一&#x…

基于考研题库小程序V2.0实现倒计时功能板块和超时判错功能

V2.0 需求沟通 需求分析 计时模块 3.1.1、功能描述←计时模块用于做题过程中对每一题的作答进行30秒倒计时&#xff0c;超时直接判错&#xff0c;同时将总用时显示在界面上;记录每次做题的总用时。 3.1.2、接口描述←与判定模块的接口为超时判定&#xff0c;若单题用时超过 …

C++:缺省参数|函数重载|引用|const引用

欢迎来到HarperLee的学习笔记&#xff01; 博主主页传送门&#xff1a;HarperLee的博客主页 想要一起进步的uu可以来后台找我哦&#xff01; 一、缺省参数 1.1 缺省参数的定义 缺省参数&#xff1a;是声明或定义函数时为函数的参数指定⼀个缺省值。在调用该函数时&#xff0c;…

MYSQL数据库建表规则及注意事项

数据类型以及应用场景 数值类型 TINYINT&#xff1a;使用在 0~1 SMALLINT&#xff1a;使用在2~10 INT&#xff1a;常用 BIGINT&#xff1a;使用在用户ID等更大范围的整数 DECIMAL&#xff1a;用于存储精确的小数。常用于需要高精度计算的场景&#xff0c;如金融数据处理。 日期…

【UE5.3】笔记10-时间轴的使用

时间轴 右键--Add Timeline(在最下面) --> 双击进入时间轴的编辑界面&#xff1a; 左上角可以添加不同类型的轨道&#xff0c;可以自定义轨道的长度&#xff0c;单位秒&#xff0c;一次可以添加多个 可以通过右键添加关键帧&#xff0c;快捷键&#xff1a;shift鼠标左键按…

JMH325【剑侠情缘3】第2版80级橙武网游单机更稳定亲测视频安装教学更新整合收集各类修改教学补丁兴趣可以慢慢探索

资源介绍&#xff1a; 是否需要虚拟机&#xff1a;是 文件大小&#xff1a;压缩包约14G 支持系统&#xff1a;win10、win11 硬件需求&#xff1a;运行内存8G 4核及以上CPU独立显卡 下载方式&#xff1a;百度网盘 任务修复&#xff1a; 1&#xff0c;掌门任务&#xff08…

MMII 的多模态医学图像交互框架:更直观地理解人体解剖结构和疾病

医生在诊断和治疗过程中依赖于人体解剖图像&#xff0c;如磁共振成像&#xff08;MRI&#xff09;&#xff0c;难以全面捕捉人体组织的复杂性&#xff0c;例如组织之间的空间关系、质地、大小等。然而&#xff0c;实时感知有关患者解剖结构和疾病的多模态信息对于医疗程序的成功…

在mysql中delete和truncated的相同点和区别点

相同点 删除数据&#xff1a;两者都会删除表中的数据。影响数据&#xff1a;两者都不删除表结构&#xff0c;只影响表中的数据。 区别点 操作方式&#xff1a; DELETE&#xff1a;逐行删除数据&#xff0c;可以使用 WHERE 子句来指定删除的条件。如果不加 WHERE 子句&#…

R包:ggsci期刊配色

介绍 不同期刊配色大多数时候不一样&#xff0c;为了更好符合期刊图片颜色的配色&#xff0c;有人开发了ggsci这个R包。它提供以下函数&#xff1a; scale_color_palname() scale_fill_palname() 对应不同期刊的color和fill函数。 导入数据R包 library("ggsci")…

LAZYNVIM学习使用笔记

文章目录 1. 前言VIM的模式快捷键参考 1. 前言 习惯使用vscode进行代码编辑&#xff0c;无意中刷到lazynvim&#xff0c;感觉功能强大&#xff0c;于是下载、安装&#xff0c;学习使用一下&#xff0c;本篇主要记录学习使用lazynvim的一些要点&#xff0c;防止遗忘。 持续更新…

Unity 打包的安卓APK在模拟器运行一会卡死

Unity 安卓APK模拟器运行一会卡死 如题&#xff0c;unity在模拟器上运行安卓apk挂机一会就卡死&#xff0c;在真机上没问题。因为打包时勾选了这个帧率优化选项&#xff0c;2019.2之后的功能&#xff0c;最坑的时打包时默认勾选&#xff0c;所以使用这个版本打包时&#xff0c…

文献阅读(1)——深度强化学习求解车辆路径问题的研究综述

doi&#xff1a; 10.3778/j.issn.1002-8331.2210-0153 深度强化学习求解车辆路径问题的研究综述 (ceaj.org) 组合最优化问题&#xff08; combinatorial optimization problem&#xff0c; COP &#xff09; 日常生活中常见的 COP 问题有旅行商问题&#xff08;traveling sale…

微调Qwen2大语言模型加入领域知识

这里写自定义目录标题 试用Qwen2做推理安装LLaMA-Factory使用自有数据集微调Qwen2验证微调效果 试用Qwen2做推理 参考&#xff1a;https://qwen.readthedocs.io/en/latest/getting_started/quickstart.html from transformers import AutoModelForCausalLM, AutoTokenizer de…

NI 5G大规模MIMO测试台:将理论变为现实

目录 概览引言MIMO原型验证系统MIMO原型验证系统硬件LabVIEW通信系统设计套件&#xff08;简称LabVIEW Communications&#xff09;CPU开发代码FPGA代码开发硬件和软件紧密集成 LabVIEW Communications MIMO应用框架MIMO应用框架特性单用户MIMO和多用户MIMO基站和移动站天线数量…

作业/数据结构/2023/7/10

1.实现单向链表队列的&#xff0c;创建&#xff0c;入队&#xff0c;出队&#xff0c;遍历&#xff0c;长度&#xff0c;销毁。 main.c #include "head.h"int main(int argc, const char *argv[]) {//创建链式队列queue_ptr QLcreate_queue();//入栈push(QL, 1000)…

OpenGL3.3_C++_Windows(29)

Demo exposure 0.1f exposure 5.0f HDR色调映射 问题&#xff1a;有多个亮光源使这些数值总和超过了1.0&#xff0c;颜色值会被约束在1.0&#xff0c;从而导致场景混成一片&#xff0c;难以分辨&#xff1a;色调映射&#xff1a;用更大范围的颜色值渲染从而获取大范围的黑暗…

手搓前端day1

断断续续的学了些前端&#xff0c;今天开始写写代码&#xff0c;就当是记录一下自己前端的成长过程 效果&#xff1a; 写了点css&#xff0c;实现了简单的前端页面的跳转 文件目录 代码如下&#xff1a; styles.css body{margin: 0;padding: 0;}header{background-color: bl…

从0-1搭建一个web项目(路由目录分析)详解

本章分析vue路由目录文件详解 ObJack-Admin一款基于 Vue3.3、TypeScript、Vite3、Pinia、Element-Plus 开源的后台管理框架。在一定程度上节省您的开发效率。另外本项目还封装了一些常用组件、hooks、指令、动态路由、按钮级别权限控制等功能。感兴趣的小伙伴可以访问源码点个赞…