【Linux】进程间通信（1）——匿名管道

news2025/1/1 23:57:09

文章目录

  • 前言
  • 进程间通信的目的
  • 进程间通信的发展
  • 进程间通信分类
  • 管道
    • 什么是管道？
    • 站在内核角度-管道本质
    • 匿名管道pipe函数
    • 管道的特点（重要）
    • 用fork来共享管道原理
    • 匿名管道的使用步骤
    • 管道的读写规则
    • 管道的四种场景
  • 如何使用管道进行进程间通信？
    • makefile
    • Task.hpp
    • ctrlPipe.cc

前言

之前所学的进程，一般进程和进程之间是独立的关系，最多产生一些耦合，比如父进程创建子进程，父进程等待子进程等等。但实际在很多问题上进程和进程之间是需要相互协同的，那么进程间通信就是在不同进程之间传播或交换信息，接下来让我们一起走进进程间通信的大门！

进程间通信的目的

  1. 数据传输：一个进程需要将它的数据发送给另一个进程。
  2. 资源共享：多个进程之间共享同样的资源。
  3. 通知事件：一个进程需要向另一个或一组进程发送消息，通知它们发送了某种事件（如子进程终止时要通知父进程）。
  4. 进程控制：有些进程希望完全控制另一个进程的执行（如debug调试进程），此时控制进程希望能够拦截另一个进程的所有陷入和异常，并能够及时直到它的状态改变。

可以形象理解成：两个人之间互相打电话，不管你们的目的是什么，是A打电话给B，叫他拿外套（进程控制），还是A通知B，今天晚上要开会（通知事件），本质都要“打电话”。

进程间通信的发展

  • 管道
  • System V进程间通信（可以实现本地通信）
  • POSIX进程间通信（可以实现跨网络通信）

进程间通信分类

管道：

  • 匿名管道pipe
  • 命名管道

System V IPC：

  • System V 消息队列
  • System V 共享内存
  • System V 信号量

POSIX IPC：

  • 消息队列
  • 共享内存
  • 信号量
  • 互斥量
  • 条件变量
  • 读写锁

任何进程通信的手段：

  1. 想办法，先让不同的进程，看到同一份资源（这一步至关重要）！！！
  2. 让一方写入，一方读取完成通信的过程，至于，通信的目的和后续的工作，要结合具体场景。
  3. 不能说让A进程在它的内存中开辟一块空间，让B进程可以访问，因为这样就破坏了进程之间具有独立性这一说。抽象如图：
    在这里插入图片描述

管道

什么是管道？

  • 管道是Unix中最古老的进程间通信的形式。
  • 我们把一个进程连接到另一个进程的一个数据流称为一个“管道”。
  • 其本质是一个伪文件（管道实为内核使用环形队列机制，借助内核缓冲区4k实现）；

在这里插入图片描述
其中，who命令和wc命令都是两个程序，当它们运行起来后就变成了两个进程，who进程通过标准输出将数据打到“管道”当中，wc进程再通过标准输入从“管道”当中读取数据，至此便完成了数据的传输，who命令用于查看当前云服务器的登录用户（一行显示一个用户），wc -l是计算行数的一个命令，说明当前只有一个用户在线，
在这里插入图片描述

站在内核角度-管道本质

在这里插入图片描述

匿名管道pipe函数

pipe函数用于创建匿名管道，pipe函数的函数原型如下：

int pipe(int pipefd[2]);

pipe函数的参数是一个输出型参数，所以用户需要定义两个数组，并传过来，数组pipefd用于返回两个指向管道读端和写端的文件描述符：

数组元素代表含义
pipefd[0]管道读端的文件
pipefd[1]管道写端的文件
pipe函数调用成功时返回0，调用失败时返回-1。

在这里插入图片描述

管道的特点（重要）

  1. 由两个文件描述符引用，一个表示读端，一个表示写端；
  2. 管道提供流式服务，规定数据从管道的写端流入管道，从读端流出。
  3. 管道是单向通信的，如果想要使用双向通信，那就创建两个管道吧；
  4. 管道通信，通常用来进行具有“血缘”关系的进程，进行进程间通信。常用于父子通信，因为具有了血缘关系，fork创建子进程后才能看到同一份资源—pipe函数打开管道，并不清楚管道的名字，称之为匿名管道。
  5. 在管道通信中，写入的次数，和读取的次数，不是严格匹配的，读写次数的多少没有强相关。——表现：面向字节流。
  6. 管道具有一定的协同能力，让读端和写端能够按照一定的步骤进行通信——自带同步进制。
  7. 一般而言，进程退出，管道就会被释放，所以管道的生命周期随进程。
  8. 一般而言，内核会对管道操作进行同步与互斥；
  9. 管道是半双工的，数据只能向一个方向流动（ps：吵架是全双工的！哈哈哈！）

用fork来共享管道原理

图上模拟的是子进程向管道写入数据，父进程从管道读取数据。在创建匿名管道实现父子进程间通信的过程中，需要pipe函数和fork函数搭配使用，具体步骤如下：
在这里插入图片描述

匿名管道的使用步骤

站在文件描述符角度-深度理解管道
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
所以，看待管道，就如同看待文件一样！管道的使用和文件一致，迎合了“Linux一切皆文件思想”。

管道的读写规则

  • 当没有数据可读时
    O_NONBLOCK disable: read调用阻塞，即进程暂停执行，一直等待有数据来为止；
    O_NONBLOCK enable: read调用返回-1,errno值为EAGAIN。

  • 当管道满的时候
    O_NONBLOCK disable: write调用阻塞，直到有进程读走数据；
    O_NONBLOCK enable: 调用返回-1,errno值为EAGAIN。

  • 如果所有管道写端对应的文件描述符被关闭，则read返回0，表面读到文件结尾；

  • 如果所有管道读端对应的文件描述符被关闭，则write操作会产生信号SIGPIPE，进而可能导致write进程退出。

  • 当要写入的数据量不大于PIPE_BUF时，linux将保证写入的原子性(即要么全做，要么都不做)。

  • 当要写入的数据量大于PIPE_BUF时，linux将不再保证写入的原子性。

管道的四种场景

  1. 数据一旦被读走，便不再管道中存在，不可反复读取。如果我们读取完毕了所有的管道数据，如果对方不写入，我们就只能等待。
  2. 如果我们写端将管道写满了，我们就不能再写了。
  3. 如果我关闭了写端，读取完管道数据后，再读，read就会返回0，表明读到了文件结尾。
  4. 如果写端一直写，读端关闭，那么写端继续写就没有意义了，OS不会维护无意义，低效率的事情，OS会杀死一直在写入的进程！通过信号来终止进程：13)SIGPIPE

下列代码演示：子进程通过写端写数据到管道，父进程读取管道数据。
实例代码：

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

int main()
{
    //父进程需要以读写的方式打开管道文件，父进程和子进程之间进行相互通信,父进程打开的管道文件地址是会被子进程继承下来的
    //所以它们指向的是同一份管道文件
    //【一定要让不同的进程看到同一份资源】
    //1.创建管道
    int pipefd[2] = {0};//将其初始化为0
    int n = pipe(pipefd);//pipefd是一个输出型参数
    if(n<0)
    {
        std::cout<<"pipe error, "<<errno<<":"<<strerror(errno)<<std::endl;
    }
    //pipe函数创建管道文件，将数组pipefd初始化成3和4，并返回，因为0,1,2已被占用
    std::cout<<"pipefd[0]: "<<pipefd[0]<<std::endl;//3->读端
    std::cout<<"pipefd[1]: "<<pipefd[1]<<std::endl;//4->写端
    
    //2.创建子进程
    pid_t id = fork();
    assert(id!=-1);//正常应该应用判断，我这里就断言

    if(id==0) //子进程
    {
        //3.关闭不需要的fd，让父进程进行读取，让子进程进行写入
        //我们想让子进程进行写入，所以关闭的是pipefd[0]读,保留pipefd[1]写
        close(pipefd[0]);

        //4.开始通信--结合某种场景---子进程将数据写入管道
        const std::string namestr = "嗨！我是子进程";
        int cnt = 1;
        char buffer[1024];
        while(true)
        {
            //先向buffer字符缓冲区格式化写入数据
            snprintf(buffer,sizeof(buffer),"%s,计数器：%d,我的PID:%d\n",namestr.c_str(),cnt++,getpid());
            //然后再将缓冲区的数据写到管道里
            write(pipefd[1],buffer,strlen(buffer));
            sleep(1);
        }

        close(pipefd[1]);

        //子进程执行完退出
        exit(0);
    }

    //父进程
    //3.为实现单向通信，需要关闭不需要的文件描述符fd
    close(pipefd[1]);

    //4.开始通信--结合某种场景---父进程从管道中读取数据
    char buffer[1024]={0};
    while(true)
    {
        //父进程先把管道里的数据读出来，放到缓冲区中
        int n = read(pipefd[0],buffer,sizeof(buffer)-1);
        if(n>0)
        {
            buffer[n]='\0';
            std::cout<<"我是父进程，子进程给我的消息是:"<<buffer<<std::endl;
        }
        else if(n==0)
        {
            std::cout<<"我是父进程，我读到文件结尾了"<<std::endl;
            break;
        }
        else
        {
            std::cout<<"我是父进程，我读异常了"<<std::endl;
        }
    }

    close(pipefd[0]);//关闭管道读端

    //父进程等待子进程
    waitpid(id,&status,0);
    std::cout<<"sig: "<<(status & 0x7) << std::endl;//如果子进程一直写，但是父进程读取一段时间后退出
    //OS就会杀掉子进程

    return 0;
}

如何使用管道进行进程间通信？

在这里插入图片描述

makefile

ctrlPipe:ctrlPipe.cc
	g++ -o $@ $^ -std=c++11
.PHONY:clean
clean:
	rm -rf ctrlPipe

Task.hpp

#pragma once

#include <iostream>
#include <vector>
#include <unistd.h>
#include <unordered_map>

// typedef std::function<void ()> func_t;

typedef void (*fun_t)(); //函数指针

void PrintLog()
{
    std::cout << "pid: "<< getpid() << ", 打印日志任务，正在被执行..." << std::endl;
}

void InsertMySQL()
{
    std::cout << "执行数据库任务，正在被执行..." << std::endl;
}

void NetRequest()
{
    std::cout << "执行网络请求任务，正在被执行..." << std::endl;
}

// void ExitProcess()
// {
//     exit(0);
// }

//约定，每一个command都必须是4字节
#define COMMAND_LOG 0
#define COMMAND_MYSQL 1
#define COMMAND_REQEUST 2

class Task
{
public:
    Task()
    {
        funcs.push_back(PrintLog);
        funcs.push_back(InsertMySQL);
        funcs.push_back(NetRequest);
    }
    void Execute(int command)
    {
        if(command >= 0 && command < funcs.size()) funcs[command]();
    }
    ~Task()
    {}
public:
    std::vector<fun_t> funcs;
};

ctrlPipe.cc

#include <iostream>
#include <string>
#include <vector>
#include <cassert>
#include <unistd.h>
#include <sys/wait.h>
#include <sys/types.h>
#include "Task.hpp"
using namespace std;

const int gnum = 3;
Task t;

class EndPoint
{
private:
    static int number;
public:
    pid_t _child_id;
    int _write_fd;
    std::string processname;
public:
    EndPoint(int id, int fd) : _child_id(id), _write_fd(fd)
    {
        //process-0[pid:fd]
        char namebuffer[64];
        snprintf(namebuffer, sizeof(namebuffer), "process-%d[%d:%d]", number++, _child_id, _write_fd);
        processname = namebuffer;
    }
    std::string name() const
    {
        return processname;
    }
    ~EndPoint()
    {
    }
};

int EndPoint::number = 0;

// 子进程要执行的方法
void WaitCommand()
{
    while (true)
    {
        int command = 0;
        int n = read(0, &command, sizeof(int));
        if (n == sizeof(int))
        {
            t.Execute(command);
        }
        else if (n == 0)
        {
            std::cout << "父进程让我退出，我就退出了: " << getpid() << std::endl; 
            break;
        }
        else
        {
            break;
        }
    }
}

void createProcesses(vector<EndPoint> *end_points)
{
    vector<int> fds;
    for (int i = 0; i < gnum; i++)
    {
        // 1.1 创建管道
        int pipefd[2] = {0};
        int n = pipe(pipefd);
        assert(n == 0);
        (void)n;

        // 1.2 创建进程
        pid_t id = fork();
        assert(id != -1);
        // 一定是子进程
        if (id == 0)
        {
            for(auto &fd : fds) close(fd);

            // std::cout << getpid() << " 子进程关闭父进程对应的写端：";
            // for(auto &fd : fds)
            // {
            //     std::cout << fd << " ";
            //     close(fd);
            // }
            // std::cout << std::endl;
            
            // 1.3 关闭不要的fd
            close(pipefd[1]);
            // 我们期望，所有的子进程读取"指令"的时候，都从标准输入读取
            // 1.3.1 输入重定向，可以不做
            dup2(pipefd[0], 0);
            // 1.3.2 子进程开始等待获取命令
            WaitCommand();
            close(pipefd[0]);
            exit(0);
        }

        // 一定是父进程
        //  1.3 关闭不要的fd
        close(pipefd[0]);

        // 1.4 将新的子进程和他的管道写端，构建对象
        end_points->push_back(EndPoint(id, pipefd[1]));

        fds.push_back(pipefd[1]);
    }
}


int ShowBoard()
{
    std::cout << "##########################################" << std::endl;
    std::cout << "|   0. 执行日志任务   1. 执行数据库任务    |" << std::endl;
    std::cout << "|   2. 执行请求任务   3. 退出             |" << std::endl;
    std::cout << "##########################################" << std::endl;
    std::cout << "请选择# ";
    int command = 0;
    std::cin >> command;
    return command;
}

void ctrlProcess(const vector<EndPoint> &end_points)
{
    // 2.1 我们可以写成自动化的，也可以搞成交互式的
    int num = 0;
    int cnt = 0;
    while(true)
    {
        //1. 选择任务
        int command = ShowBoard();
        if(command == 3) break;
        if(command < 0 || command > 2) continue;
        
        //2. 选择进程
        int index = cnt++;
        cnt %= end_points.size();
        std::string name = end_points[index].name();
        std::cout << "选择了进程: " <<  name << " | 处理任务: " << command << std::endl;

        //3. 下发任务
        write(end_points[index]._write_fd, &command, sizeof(command));

        sleep(1);
    }
}

void waitProcess(const vector<EndPoint> &end_points)
{
    // 1. 我们需要让子进程全部退出 --- 只需要让父进程关闭所有的write fd就可以了！
    // for(const auto &ep : end_points) 
    // for(int end = end_points.size() - 1; end >= 0; end--)
    for(int end = 0; end < end_points.size(); end++)
    {
        std::cout << "父进程让子进程退出:" << end_points[end]._child_id << std::endl;
        close(end_points[end]._write_fd);

        waitpid(end_points[end]._child_id, nullptr, 0);
        std::cout << "父进程回收了子进程:" << end_points[end]._child_id << std::endl;
    } 
    sleep(10);

    // 2. 父进程要回收子进程的僵尸状态
    // for(const auto &ep : end_points) waitpid(ep._child_id, nullptr, 0);
    // std::cout << "父进程回收了所有的子进程" << std::endl;
    // sleep(10);
}


// #define COMMAND_LOG 0
// #define COMMAND_MYSQL 1
// #define COMMAND_REQEUST 2
int main()
{
    vector<EndPoint> end_points;
    // 1. 先进行构建控制结构, 父进程写入，子进程读取 ， bug?
    createProcesses(&end_points);

    // 2. 我们的得到了什么？end_points
    ctrlProcess(end_points);

    // 3. 处理所有的退出问题
    waitProcess(end_points);
    return 0;
}

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

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

相关文章

【Vue3学习】Vuex 状态管理 store

【Vue3学习】Vuex 状态管理 store

Vuex 是一个专为 Vue.js 应用程序开发的状态管理模式 库。它采用集中式存储管理应用的所有组件的状态&#xff0c;并以相应的规则保证状态以一种可预测的方式发生变化。 安装 npm npm install vuexnext --saveyarn npm install vuexnext --save基本使用 1&#xff09;创建…
阅读更多...
Kubernetes初认识

Kubernetes初认识

系列文章目录 文章目录 系列文章目录一、Kubernetes初认识1.k8s的特性2.K8S架构3.Kubernetes工作流程 二、K8S创建Pod流程1.详细版2.简单版 总结 一、Kubernetes初认识 1.k8s的特性 弹性伸缩&#xff1a;使用命令、UI或者基于CPU使用情况自动快速扩容和缩容应用程序实例&…
阅读更多...
磁盘调度算法及其应用

磁盘调度算法及其应用

导读&#xff1a; 磁盘调度是计算机系统中的重要问题之一。在多个进程同时访问磁盘时&#xff0c;合理的磁盘调度算法可以优化磁盘访问顺序&#xff0c;提高系统性能。本文将介绍磁盘调度算法的基本思想&#xff0c;并通过一个实验来模拟不同调度算法的运行过程。 正文&#…
阅读更多...
如何翻译 Markdown 文件？-2-几种商业及开源解决方案介绍

如何翻译 Markdown 文件？-2-几种商业及开源解决方案介绍

背景 近期在搭建英文博客-<e-whisper.com>, 需要对现有的所有中文 Markdown 翻译为英文。 需求如下&#xff1a; 将 Markdown 文件从中文 (zh-CN) 翻译为英文 (en)翻译后要保留 Markdown 的完整格式部分 Markdown block 不需要翻译&#xff0c;如&#xff1a;front-ma…
阅读更多...
电脑蓝屏问题

电脑蓝屏问题

如何使用DISM命令行工具修复Windows 10映像 - 系统极客 (sysgeek.cn) 电脑每周基本都会出现一次蓝屏问题&#xff1a;THREAD_STUCK_IN_DEVICE_DRIVER 售后重装系统&#xff0c;换主板&#xff0c;换硬盘都没有用&#xff0c;实在是人麻了 不知道有没有用&#xff0c;先记录一…
阅读更多...
“边玩边赚”的区块链游戏发展前景和趋势

“边玩边赚”的区块链游戏发展前景和趋势

2008年&#xff0c;一个真实的故事。 大学期间&#xff0c;睡在我下铺的兄弟没日没夜地玩一款电脑游戏——《热血江湖》&#xff0c;期末考试和考研都没能阻止他。而最终&#xff0c;是游戏里的一把枪让他改邪归正。因为他把那件装备卖给了一个北京人&#xff0c;价格高达3000…
阅读更多...
IT专业相关介绍【活动】

IT专业相关介绍【活动】

IT专业相关介绍【活动】 前言IT专业相关介绍一、IT专业的就业前景和发展趋势二、了解IT专业的分类和方向三、你对本专业的看法和感想四、本专业对人能力素养的要求五、建议和思考六、计算机思维能力测试 最后 前言 2023-6-17 10:00:29 以下内容源自《【活动】》 仅供学习交流…
阅读更多...
Spring-kafka的消费者模型和实现原理

Spring-kafka的消费者模型和实现原理

在使用Spring-kafka时，一般都是通过使用@KafkaListener注解的方法来实现消息监听和消费。今天写一下基于这个注解实现的消费端模型和实现的原理。 Kafka消费模型 我们在使用@KafkaListener注解实现消费者时消费者模型是这样的： 每个@KafkaListener注解对应有一个Concurren…
阅读更多...
python窗口程序button事件处理

python窗口程序button事件处理

import tkinter as tk def add_counter(): #增加计数print("add....")def zero_counter(): #归零计数print("zero....")#窗口的属性&#xff08;大小&#xff0c;&#xff09; root tk.Tk() root.geometry("400x200200200") root.title(&q…
阅读更多...
亚马逊云科技中国峰会：深度学习Amazon DeepRacer

亚马逊云科技中国峰会：深度学习Amazon DeepRacer

序言 Amazon DeepRacer是什么&#xff1f; Amazon DeepRacer是亚马逊推出的一款基于深度学习和强化学习技术的自主驾驶模拟赛车平台。它提供了一个云端仿真环境和一个物理赛车模型&#xff0c;让用户可以通过编写代码和训练模型来控制赛车的行驶&#xff0c;从而学习和应用深…
阅读更多...
【LeetCode】HOT 100（14）

【LeetCode】HOT 100（14）

题单介绍&#xff1a; 精选 100 道力扣&#xff08;LeetCode&#xff09;上最热门的题目&#xff0c;适合初识算法与数据结构的新手和想要在短时间内高效提升的人&#xff0c;熟练掌握这 100 道题&#xff0c;你就已经具备了在代码世界通行的基本能力。 目录 题单介绍&#…
阅读更多...
音视频开发Level0: 入门级20～25k的工作

音视频开发Level0: 入门级20～25k的工作

今天给大家分享一个音视频开发领域&#xff0c;入门级别的工作&#xff0c;要求不高。 主要做什么呢&#xff0c;行车记录仪&#xff0c;运动相机&#xff0c;各种拍摄器材包括医疗领域的喉镜啊&#xff0c;等等。 这种产品&#xff0c;招人的公司深圳最多&#xff0c;因为深…
阅读更多...
Mac 多版本jdk安装与切换

Mac 多版本jdk安装与切换

macOS上可以安装多个版本的jdk&#xff0c;方法如下&#xff1a; 1.下载jdk 在Oracle官网上下载不同版本的jdk&#xff1a; JDK下载 知乎 - 安全中心 下载Java11版本链接 jdk11​www.oracle.com/java/technologies/javase-jdk11-downloads.html 2.安装jdk 运行此安装包&…
阅读更多...
electron-vue 安装 sqlite3 详细步骤

electron-vue 安装 sqlite3 详细步骤

1 安装 Visual Studio 2019 使用 Visual Studio instaler 安装Visual Studio 2019&#xff0c; 安装桌面应用 使用c的桌面开发, 勾选 MSVC 相应的选项。 2. 安装 node 13 版本 可以根据自己实际情况安装版本 使用 cmd 管理员身份或者 powerShell 管理员身份 执行以下命令&…
阅读更多...
骨传导蓝牙立体声耳机怎么选，列举几款值得购买的骨传导耳机

骨传导蓝牙立体声耳机怎么选，列举几款值得购买的骨传导耳机

骨传导耳机的出现&#xff0c;使得很多人摆脱了佩戴入耳式耳机的困扰&#xff0c;同时也为骨传导耳机的发展起到了很大的推动作用。骨传导耳机是一种通过骨头传声的耳机&#xff0c;由于其不需要入耳&#xff0c;所以不会因为长时间佩戴而引起耳道的不适感&#xff0c;在使用时…
阅读更多...
baichuan-7B: 开源可商用支持中英文的最好大模型

baichuan-7B: 开源可商用支持中英文的最好大模型

背景 baichuan-7B 是由百川智能开发的一个开源可商用的大规模预训练语言模型。 基于 Transformer 结构&#xff0c;在大约1.2万亿 tokens 上训练的70亿参数模型&#xff0c;支持中英双语&#xff0c;上下文窗口长度为4096。 在标准的中文和英文权威 benchmark&#xff08;C-…
阅读更多...
【FreeRTOS】——列表与列表项列表相关API函数（初始化、插入、移除）

【FreeRTOS】——列表与列表项列表相关API函数（初始化、插入、移除）

目录 前言&#xff1a; 一、列表与列表项 二、列表相关API函数 ①初始化列表vListInitialise() ②初始化列表项vListInitialise() ③列表插入列表项&#xff08;升序&#xff09;函数vListInsert() ④列表插入列表项&#xff08;无序&#xff09;函数vListInsertEnd() …
阅读更多...
开源赋能 普惠未来——回顾全球数字经济大会及开放原子全球开源峰会（Intel专题）

开源赋能 普惠未来——回顾全球数字经济大会及开放原子全球开源峰会（Intel专题）

一、峰会背景 2023年6月11日至13日&#xff0c;中国北京迎来了一场全球数字经济大会和开放原子全球开源峰会的盛会。这次大会在北京北人亦创国际会展中心隆重举行&#xff0c;为来自世界各地的数字经济和开源社区的代表们提供了一个共同交流、合作的平台。 本次大会以"开…
阅读更多...
GAMES101笔记 Lecture02 线性代数基础

GAMES101笔记 Lecture02 线性代数基础

目录 A Swift and Brutal Introduction to Linear AlgebraGarphics Dependencies(图形学的依赖)Basic mathematics(基础的数学)Basic physics(基础的物理)Misc(杂项)And a bit of asethetics(以及一点美学) Vectors(向量)Vector Normalization(向量归一化)Vector Addition(向量…
阅读更多...
记录好项目D7

记录好项目D7

记录好项目 你好呀&#xff0c;这里是我专门记录一下从某些地方收集起来的项目&#xff0c;对项目修改&#xff0c;进行添砖加瓦&#xff0c;变成自己的闪亮项目。修修补补也可以成为毕设哦 本次的项目是个酒店预订管理系统 技术栈&#xff1a;springbootjavamysqlmybatis …
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023