【Linux】文件描述符（下篇）

news2025/1/12 18:06:55

文章目录

  • 📖 前言
  • 1. 文件描述符fd的分配规则
  • 2. 重定向的本质
  • 3. 缓冲区的理解
    • 3.1 感受缓冲区的存在：
    • 3.2 正式认识缓冲区：
      • 综合例题：
  • 4. 模拟实现C语言的文件操作
  • 5. 完善之前实现的shell
    • 5.1 程序替换，会影响曾经子进程打开的文件吗？

📖 前言

紧接着上篇的文件描述符，我们要继续讲解文件描述符，通过文件描述符讲解重定向的原理，再用所学的知识自己模拟实现一下C语言中fopen等文件操作，讲解一下缓冲区，最后再完善一下我们之前实现的shell。目标已经确定，接下来就要搬好小板凳，准备开讲了…🙆🙆🙆🙆

1. 文件描述符fd的分配规则

上一篇我们已经讲述了文件操作的内核中实现的映射关系，并且画了图理解了一遍。

创建struct file，初始化内部属性，函数指针指向对应方法，将这个对象的struct file地址填到，进程对应的文件描述表里面，分配一个指针数组没有被占用的下标，将数字下标返回。

那么这些下标fd都是如何分配的呢？

我们接下来做个小实验，将1号文件关掉，再创建一个文件，看其文件的fd是什么：

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>

int main()
{
    close(1);

    int fd = open("log.txt", O_WRONLY | O_CREAT | O_TRUNC, 0666);

    if(fd < 0)
    {
        perror("open");
        return 0;
    }

    fprintf(stdout, "打开文件成功，fd : %d\n", fd);
    fflush(stdout);

    return 0;
}

我们显示一开始关闭了0号文件：

在这里插入图片描述
我们看到了fd为0，这就说明了，内核中struct file* fd array[]数组中0号下标是log.txt的文件的fd。
我们关闭了0号，关了之后0号又被打开，指向了别的文件。

结论：

从头遍历数组fd array[]，找到一个最小的，没有被使用的下标，分配给新的文件！！

2. 重定向的本质

在之前学习Linux基础指令时，我们学过重定向操作，向指定文本中写入或追加文件内容。
而现在我们在了解文件内核基本结构之后，我们就可以理解重定向的本质了。

  • 重定向是一种通过修改标准输入、标准输出和标准错误流的方式来改变程序的输入和输出方向的技术~
  • 以我们现在所学的知识，完全可以实现，只需要将stdout关掉。
  • 再将1号位置存的指针改成要被写入的文件的 files_struct 结构体的指针即可，这样写入就是往该文件写入了。
  • 先close是先将1号描述符对应的对象设置成空，然后将新文件的文件对象的地址填入。
  • 但是重定向可不用这么麻烦，有接口可供我们使用。

一堆的数据，都是内核数据结构，只有OS有权限，必定提供对应的接口~

dup函数：

dup函数的作用是创建一个新的文件描述符，该描述符是原始文件描述符的副本。

在这里插入图片描述
返回值：

在这里插入图片描述

dup函数返回新的文件描述符，如果复制成功，则返回的文件描述符与oldfd具有相同的值和属性。如果复制失败，则返回-1，并设置errno来指示错误的原因。

我们要弄清楚谁是谁的一份拷贝，一定是oldfd拷贝给了newfd（newfd的内容是oldfd的一份拷贝），最后两个都是oldfd，别弄反了~

在这里插入图片描述
输出重定向：

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>

int main()
{
    int fd = open("log.txt", O_WRONLY | O_CREAT | O_TRUNC, 0666);

    if(fd < 0)
    {
        perror("open");
        return 1;
    }

    //本来1号位置的指针，被覆盖成了3号位置的指针
    int ret = dup2(fd, 1); //fd = 3, 1
    if(ret > 0) close(fd);

    printf("ret : %d\n", ret);

    //本来应该要往显示器打印，最终却变成了向指定文件打印 -- 重定向的原理
    fprintf(stdout, "打开文件成功, fd: %d\n", fd);

    //暂时不做解释，后面再说 -- 和缓冲区有关
    fflush(stdout);
    close(fd);

    return 0;
}

追加重定向：

在这里插入图片描述
在这里插入图片描述

输入重定向：

int main()
{
    int fd = open("log.txt", O_RDONLY);

    if(fd < 0)
    {
        perror("open");
        return 1;
    }
    
    char line[64];
    //输入定向
    dup2(fd, 0);

    while(fgets(line, sizeof(line), stdin) != NULL)
    {
        printf("%s", line);
    }

    close(fd);

    return 0;
}

从log.txt文件内容通过fgets按行读取，读取完之后再用循环体将内容打印出来。

注意：

  • 文件地址的拷贝，拷贝的是指向。
  • 拷贝的是指针（file*）
  • 是将数组下标对应的内容做拷贝，拷贝的是里面的内容，不是拷贝整数。

总结：

如果我们要进行重定向，上层只认0, 1, 2, 3, 4, 5这样的fd，我们可以在OS内部， 通过一定的方式调整数组的特定下标的内容（指向），我们就可以完成重定向操作！

3. 缓冲区的理解

3.1 感受缓冲区的存在：

上述代码结果我们已经看了，如果我们关闭的是1号文件呢？

int main()
{
    close(1);
    //根据fd的分配规则，新的fd值一定是1
    int fd = open("log.txt", O_WRONLY | O_CREAT | O_TRUNC, 0666);

    if(fd < 0)
    {
        perror("open");
        
        return 1;
    }

    //printf -> stdout -> 1 -> 虽然不再指向对应的显示器了，但是已经指向了log.txt的底层struct file对象！
    printf("fd : %d\n", fd);

    fflush(stdout);

    close(fd);
    return 0;
}

printf -> stdout -> 1 -> 虽然不再指向对应的显示器了，但是已经指向了log.txt的底层struct file对象！

既然是向log.txt写入，我们运行之后，来看一下log.txt中的结果：

在这里插入图片描述

文件中并没有内容，这就是因为缓冲区的存在，我们需要用到fflush(stdout);来刷新一下缓冲区，不然就不会显示。

有个疑问：

  • 为什么在进程结束之后缓冲区的内容没有直接刷新到 log.txt 文件当中呢？
    • 在我们之前的学习中知道，进程结束就会将缓冲区的内容刷新到显示器上。
    • 因为之前都是向显示器刷新，stdout并没有被关闭，1号没有分配新的fd。
    • 对于标准输出流 stdout，当进程正常结束时，缓冲区的内容通常会被刷新到1号文件中。
  • 没有刷新到 log.txt 文件的原因：
    • 当进程正常终止时，操作系统会负责清理和关闭打开的文件描述符，包括标准输出流。
    • 所以最后一行的close(fd)会关闭文件描述符1，导致标准输出流被关闭。
    • 在关闭之前，操作系统会尝试将缓冲区中的内容刷新到对应的文件中。
    • 在进程结束之前，缓冲区的内容会被刷新到 stdout（标准输出流）中。
    • 然而在关闭标准输出流之前，缓冲区的内容并没有被刷新到文件中，因此最终没有将内容写入文件。
    • 而将close(fd)去掉则会刷新到log.txt这个文件里，因为在关闭文件之前就刷新了。

正确做法：

为了确保缓冲区的内容被正确刷新到文件中，可以在关闭文件描述符之前进行一次输出操作，或者显式地使用 fflush(stdout) 函数来手动刷新缓冲区。这样可以保证在关闭文件描述符之前，缓冲区的内容会被刷新到文件中。

总之，在进程正常终止前，操作系统会尽力将缓冲区的内容刷新到stdout，但不能保证一定成功。因此，最好使用fflush函数或其他相关函数来确保缓冲区的内容被刷新到文件中。

3.2 正式认识缓冲区：

  • 什么是缓冲区？
  • 缓冲区的本质，就是一段内存。
  • 为什么要有缓冲区？
  • 解放使用缓冲区的进程时间。
  • 缓冲区的存在可以集中处理数据刷新，减少IO的次数。
  • 从而达到提高整机的效率的目的。
  • 缓冲区在哪里？
  • FILE 指针是一个指向 FILE 结构体的指针，该结构体包含了有关文件的信息和状态。
  • 通过 FILE 指针，程序可以对文件进行读取、写入和定位等操作。
  • 所以这个结构体中封装了文件的很多属性。
  • 例如fd，还有该FILE对应的语言级别的缓冲区！

既然缓冲区在FILE内部，在C语言中，而我们每一次打开一个文件，都要有一个FILE*会返回！
是不是意味着，每一个文件都有一个fd和属于它自己的与语言级别缓冲区！是的！！

#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>

int main()
{
    //printf没有立即刷新的原因，是因为有缓冲区的存在
    //数据被暂存在了缓冲区里面，当进程退出时，数据才被刷新
    
    //首先printf内部就是封装了write
    printf(" hello printf"); // stdout -> 1
    fprintf(stdout, " hello fpritnf");
    fputs(" hello fputs", stdout);
   
    //write可是立即刷新的！printf -> write 
    //那么这个缓冲区在哪里？？ -- 只能是C语言提供的，是个语言级别的缓冲区
    //那么这个缓冲区不在那里？？ -- 一定不在write内部！
    //那么我们曾经谈论的缓冲区，不是内核级别的
    
    const char* msg = " hello write";
    write(1, msg, strlen(msg));

    //close(1);

    sleep(5);

    close(stdout->_fileno);

    return 0;
}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

因为这些函数底层调用write函数就失败了。

  • 首先printf内部就是封装了write。
  • 立刻刷新，所以sleep的时候数据并没有立刻显示出来。
  • 不带缓冲区代表数据没法立即刷新。加上fflush就可以立即刷新出来了。
  • fprintf、fputs和printf一样都是等待再刷新，等到进程退出的时候刷新。
  • 这几个接口底层都封装了write。

为什么会出现等几秒钟才刷新出来的现象？

  • 不是直接调用write接口，写到操作系统最后刷到硬件上的。
  • 而是直接把数据写到了cache里面。
  • 当数据量积累到一定程度，会定期的通过fd去调用write把数据刷新到内存中。

那么这个缓冲区在哪里？？

  • 只能是C语言提供的，是个语言级别的缓冲区。

那么这个缓冲区不在那里？？

  • 一定不在write内部！
  • 那么我们曾经谈论的缓冲区，不是内核级别的。

fprintf、fputs和printf这三个接口都是C语言提供的，都有一个公共参数 — stdout。printf也有只是没有写出来而已。stdout是FILE结构体的指针。

  • 缓冲区刷新策略：
  • 什么时候刷新？
  • 常规：
    • 无缓冲（立即刷新）
    • 行缓冲（逐行刷新），显示器文件。
    • 全缓冲（缓冲区满，刷新），块设备对应的文件，磁盘文件。
  • 特殊：
    • 进程退出
    • 用户强制刷新

根据文件类型来决定刷新策略。

综合例题：

下面程序的可执行程序test，重定向到log.txt文件中，那么log.txt文件中的内容是什么？

#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>

int main()
{
    const char* str1 = "hello printf\n";
    const char* str2 = "hello fprintf\n";
    const char* str3 = "hello fputs\n";
    const char* str4 = "hello write\n";

    //C库函数
    printf(str1);
    fprintf(stdout, str2);
    fputs(str3, stdout);

    //系统接口
    write(1, str4, strlen(str4));

    //是调用完了上面的代码，才执行的fork()
    fork();

    return 0;
}

在这里插入图片描述

  • 因为此时已经重定向到了log.txt所以不会立即刷新而变成了全缓冲。
  • 缓冲方式变化了，从行缓冲变成了全缓冲。
  • 父子进程结束，代码父子进程共享，数据要以写时拷贝的形式各自有一份。
  • 最终父进程刷一份，子进程刷一份，就会出现上述结果。
  • 缓冲区，是自己的FILE内部维护的，属于父进程内部的数据区域！
  • 写时拷贝，子进程内部缓冲区也有一份。

4. 模拟实现C语言的文件操作

有了之前的知识储备，我们可以封装系统调用接口，模拟一个缓冲区，来模拟实现C语言的文件操作接口的：

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>
#include <assert.h>

#define NUM 1024

//定义三种缓冲区刷新方式
#define NONE_FLUSH 0x0
#define LINE_FLUSH 0x1
#define FULL_FLUSH 0x2

typedef struct _MyFILE
{
    int _fileno;
    char _buffer[NUM];
    int _end;
    int _flags; //fflush method -- 刷新方式
} MyFILE;

MyFILE* my_fopen(const char* filename, const char* method)
{
    assert(filename);
    assert(method);

    //默认以读的方式打开
    int flags = O_RDONLY;

    if(strcmp(method, "r") == 0)
    {}
    else if(strcmp(method, "r+") == 0)
    {}
    else if(strcmp(method, "w") == 0)
    {
        flags = O_WRONLY | O_CREAT | O_TRUNC;
    }
    else if(strcmp(method, "w+") == 0)
    {}
    else if(strcmp(method, "a") == 0)
    {
        flags = O_WRONLY | O_CREAT | O_APPEND;
    }
    else if(strcmp(method, "a+") == 0)
    {}

    int fileno = open(filename, flags, 0666);
    if(fileno < 0)
    {
        return NULL;
    }

    MyFILE*fp = (MyFILE *)malloc(sizeof(MyFILE));

    if(fp == NULL) return fp;
    memset(fp, 0, sizeof(MyFILE));
    fp->_fileno = fileno;
    fp->_flags |= LINE_FLUSH;
    fp->_end = 0;

    return fp;
}

void my_fflush(MyFILE* fp)
{
    assert(fp);

    if(fp->_end > 0)
    {
        write(fp->_fileno, fp->_buffer, fp->_end);
        fp->_end = 0;
        syncfs(fp->_fileno);
    }
}

void my_fwrite(MyFILE* fp, const char* start, int len)
{
    assert(fp);
    assert(start);
    assert(len > 0);

    //abcde123
    //写入到缓冲区里面 -- 每次都像结尾开始写
    strncpy(fp->_buffer + fp->_end, start, len); //将数据写入到缓冲区了
    fp->_end += len;

    if(fp->_flags & NONE_FLUSH)
    {}
    else if(fp->_flags & LINE_FLUSH)
    {
        if(fp->_end > 0 && fp->_buffer[fp->_end - 1] == '\n')
        {
            //仅仅是写入到内核中
            write(fp->_fileno, fp->_buffer, fp->_end);
            fp->_end = 0;

            //真正把数据刷到磁盘上
            syncfs(fp->_fileno);
        }
    }
    else if(fp->_flags & FULL_FLUSH)
    {}
}

void my_fclose(MyFILE* fp)
{
    my_fflush(fp);
    close(fp->_fileno);
    free(fp);
}

int main()
{
    MyFILE* fp = my_fopen("log.txt", "w");
    if(fp == NULL)
    {
        printf("my_fopen error\n");
        return 1;
    }

    const char* s = "hello my 111\n";
    my_fwrite(fp, s, strlen(s));
    printf("消息立即刷新");
    sleep(3);

    const char* ss = "hello my 222";
    my_fwrite(fp, ss, strlen(ss));
    printf("写入了一个不满足刷新条件的字符串\n");
    sleep(3);

    const char* sss = "hello my 333";
    my_fwrite(fp, sss, strlen(sss));
    printf("写入了一个不满足刷新条件的字符串\n");
    sleep(3);


    const char* ssss = " end\n";
    my_fwrite(fp, ssss, strlen(ssss));
    printf("写入了一个满足刷新条件的字符串\n");
    sleep(3);

    const char* sssss = "-aaaaaaa\n";
    my_fwrite(fp, sssss, strlen(sssss));
    printf("写入了一个不满足刷新条件的字符串\n");
    fork();

    //模拟进程退出 -- 代码父进程执行一遍，子进程执行一遍
    my_fclose(fp);

    return 0;
}

把数据写到内核里，并不代表就是把数据写到硬件上了。 如果非要写到硬件上就要加上一个接口sync。

在这里插入图片描述

在这里插入图片描述
通过监控脚本，我们来观察一下：

在这里插入图片描述

5. 完善之前实现的shell

之前在学习进程程序替换的时候，我们模拟实现过一个shell【实现简易shell-复习传送门】。

没改进之前会出现的情况：
在这里插入图片描述
我们要对输入的命令做检查，对重定向操作符做单独处理。

单独加一个函数：

void CheckDir(char* commands)
{
    assert(commands);

    //[start, end)
    char* start = commands;

    //指向的是字符串最后的那个'\0' 
    char* end = commands + strlen(commands);

    //ls -a -l>log.txt
    while(start < end)
    {
        if(*start == '>')
        {
            if(*(start + 1) == '>')
            {
                //ls -a -l>>log.txt -- 追加
                *start = '\0';
                start += 2;
                g_redir_flag = APPEND_REDIR;
                DROP_SPACE(start);
                g_redir_filename = start;
                break;
            }
            else 
            {
                //ls -a -l > log.txt -- 输出重定向
                *start = '\0';
                start++;
                DROP_SPACE(start);
                g_redir_flag = OUTPUT_REDIR;
                g_redir_filename = start;
                break; 
            }
        }
        else if(*start == '<')
        {
            //输入重定向
            *start = '\0';
            start++;
            DROP_SPACE(start);
            g_redir_flag = INPUT_REDIR;
            g_redir_filename = start;
            break;
        }
        else 
        {
            start++;
        }
    }
}

其他的一些操作：

在这里插入图片描述
在这里插入图片描述

5.1 程序替换，会影响曾经子进程打开的文件吗？

—— 不影响！！

  • 程序替换只影响该进程对应的代码和数据
  • 曾经打开的文件，以及维护进程和文件之间映射关系的文件描述符表
  • 都叫做内核数据结构，和PCB一样不受程序替换的影响

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

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

相关文章

机器学习技术（三）——机器学习实践案例总体流程

机器学习技术（三）——机器学习实践案例总体流程

机器学习实践案例总体流程 文章目录 机器学习实践案例总体流程一、引言二、案例1、决策树对鸢尾花分类1.数据来源2.数据导入及描述3.数据划分与特征处理4.建模预测 2、各类回归波士顿房价预测1.案例数据2.导入所需的包和数据集3.载入数据集&#xff0c;查看数据属性&#xff0c…
阅读更多...
【动态规划算法练习】day15

【动态规划算法练习】day15

文章目录 一、01背包1.题目简介2.解题思路3.代码4.运行结果 二、416. 分割等和子集1.题目简介2.解题思路3.代码4.运行结果 三、494. 目标和1.题目简介2.解题思路3.代码4.运行结果 四、1049. 最后一块石头的重量 II1.题目简介2.解题思路3.代码4.运行结果 总结 一、01背包 1.题目…
阅读更多...
【设计模式】第十三章：模板方法模式详解及应用案例

【设计模式】第十三章：模板方法模式详解及应用案例

系列文章 【设计模式】七大设计原则 【设计模式】第一章&#xff1a;单例模式 【设计模式】第二章&#xff1a;工厂模式 【设计模式】第三章&#xff1a;建造者模式 【设计模式】第四章&#xff1a;原型模式 【设计模式】第五章&#xff1a;适配器模式 【设计模式】第六章&…
阅读更多...
20.BeautifulSoup库的安装及导入

20.BeautifulSoup库的安装及导入

文章目录 1.BeautifulSoup库简介2.BeautifulSoup库的安装3.BeautifulSoup和beautifulsoup4的区别4.获取网页源代码知识回顾4.1 手动获取网页的源代码4.2 requests库获取网页的源代码 5. 利用bs4库输出网页源代码6.bs4库的导入语法 1.BeautifulSoup库简介 BeautifulSoup库是Pyt…
阅读更多...
1.监控分布式--zabbix

1.监控分布式--zabbix

文章目录 监控分布式-zabbix、prometheus概念工作原理功能组件部署zabbix安装Nginx和PHP环境部署数据库编码安装zabbix编译安装zabbix server客户端安装zabbix agent服务 监控分布式-zabbix、prometheus 利用一个优秀的监控软件&#xff0c;我们可以: 通过一个友好的界面进行…
阅读更多...
NGINX+Tomcat负载均衡、动静分离集群

NGINX+Tomcat负载均衡、动静分离集群

目录 前言 一、NGINX正向代理与反向代理 1.1、NGINX正向代理 1.2、NGINX反向代理 1. 2.1Nginx配置反向代理的主要参数 二、负载均衡 三、NGINX动静分离集群 3.1动静分离原理 四、NginxTomcat动静分离 4.1搭建nginx代理服务器192.168.14.100 4.1.1安装 NGINX依赖环境 …
阅读更多...
创建UI组件库后上传NPM

创建UI组件库后上传NPM

上篇已经讲了如何创建自己的组件库&#xff0c;这篇讲怎么上传npm后&#xff0c;可以下载使用 1.首先看下组件的文件结构 在index.js中要写上每个组件可以按需引用的条件 import Button from "./src/button";Button.install function(Vue) {Vue.component(Button.…
阅读更多...
Tkinter_使用Progressbar创建和管理进度条

Tkinter_使用Progressbar创建和管理进度条

前言 Progressbar是Tkinter库中的一个小部件&#xff0c;用于创建和管理进度条。它可以在图形用户界面中显示任务的进度&#xff0c;并提供了多种样式和配置选项。 使用Progressbar&#xff0c;你可以按照固定或不确定的进度展示任务的进行状态。它可以显示任务完成的百分比&am…
阅读更多...
“this“ 隐式具有类型 “any“,因为它没有类型注释。

“this“ 隐式具有类型 “any“,因为它没有类型注释。

在 tsconfig.json文件中 将 "noImplicitThis" 改为false "noImplicitThis": false,
阅读更多...
工业互联网如何促进传统制造业的高效生产？

工业互联网如何促进传统制造业的高效生产？

工业互联网&#xff0c;也称为工业物联网&#xff08;IIoT&#xff09;&#xff0c;是指将联网设备和系统集成到传统制造流程中。它结合了传感器、数据分析、机器学习和自动化&#xff0c;以优化和提高制造各个方面的效率。工业互联网促进传统制造业高效生产的方式有&#xff1…
阅读更多...
机器学习、监督学习、无监督学习基本概念

机器学习、监督学习、无监督学习基本概念

- 机器学习 机器学习是一门多领域交叉学科&#xff0c;涉及概率论、统计学、逼近论、凸分析、算法复杂度理论等多门学科。专门研究计算机怎样模拟或实现人类的学习行为&#xff0c;以获取新的知识或技能&#xff0c;重新组织已有的知识结构使之不断改善自身的性能。机器学习有…
阅读更多...
Nginx反向代理提示413 Request Entity Too Large

Nginx反向代理提示413 Request Entity Too Large

请求返回的内容如下 <html> <head><title>413 Request Entity Too Large</title></head> <body> <center><h1>413 Request Entity Too Large</h1></center> <hr><center>nginx/1.20.2</center>…
阅读更多...
BPM工作流引擎优势

BPM工作流引擎优势

什么是BPM工作流引擎&#xff1f; BPM工作流引擎是对企业的业务进行的管理&#xff0c;是一个开放性的平台。它是BPM与工作流引擎的结合。不仅能够实现所有OA的功能&#xff0c;还能够实现以端到端为中心的协作&#xff0c;重视企业从战略到执行自上而下的流程化、规范化管理&a…
阅读更多...
用OpenCV创建一张类型为CV_8UC1的单通道随机灰度图像

用OpenCV创建一张类型为CV_8UC1的单通道随机灰度图像

#include <iostream> #include <opencv2/imgcodecs.hpp> #include <opencv2/opencv.hpp> #include <opencv2/highgui.hpp>int
阅读更多...
差分进化算法（Differential Evolution，DE，附简单案例及详细matlab源码）

差分进化算法（Differential Evolution，DE，附简单案例及详细matlab源码）

作者&#xff1a;非妃是公主 专栏&#xff1a;《智能优化算法》 博客地址&#xff1a;https://blog.csdn.net/myf_666 个性签&#xff1a;顺境不惰&#xff0c;逆境不馁&#xff0c;以心制境&#xff0c;万事可成。——曾国藩 文章目录 专栏推荐序一、概论二、差分进化算法&a…
阅读更多...
7、Maxwell安装部署

7、Maxwell安装部署

1、Maxwell简介 1.1 Maxwell概述 Maxwell 是由美国Zendesk公司开源&#xff0c;用Java编写的MySQL变更数据抓取软件。它会实时监控Mysql数据库的数据变更操作&#xff08;包括insert、update、delete&#xff09;&#xff0c;并将变更数据以 JSON 格式发送给 Kafka、Kinesi等…
阅读更多...
java项目之KTV点歌系统源码（ssm+jsp+mysql）

java项目之KTV点歌系统源码（ssm+jsp+mysql）

风定落花生&#xff0c;歌声逐流水&#xff0c;大家好我是风歌&#xff0c;混迹在java圈的辛苦码农。今天要和大家聊的是一款基于ssm的KTV点歌系统。项目源码以及部署相关请联系风歌&#xff0c;文末附上联系信息 。 &#x1f495;&#x1f495;作者&#xff1a;风歌&#xff0…
阅读更多...
FPGA实验六：PWM信号调制器设计

FPGA实验六：PWM信号调制器设计

目录 一、实验目的 二、设计要求 三、实验代码 1.顶层文件代码 2.仿真文件部分代码 3.系统工程文件 四、实验结果及分析 1、引脚锁定 2、仿真波形及分析 3、下载测试结果及分析 五、实验心得 一、实验目的 &#xff08;1&#xff09;掌握通信信号调制过程及实现原理…
阅读更多...
Linux调优–I/O 调度器

Linux调优–I/O 调度器

Linux 的 I/O 调度器是一个以块式 I/O 访问存储卷的进程&#xff0c;有时也叫磁盘调度器。Linux I/O 调度器的工作机制是控制块设备的请求队列&#xff1a;确定队列中哪些 I/O 的优先级更高以及何时下发 I/O 到块设备&#xff0c;以此来减少磁盘寻道时间&#xff0c;从而提高系…
阅读更多...
Android TEE可信计算环境与TrustZone基础

Android TEE可信计算环境与TrustZone基础

文章目录 前言可信计算环境TEE嵌入式安全现状现有的TEE分类TEE的应用场景TEE存在必要性 TrustZone移动端数据隔离安全/非安全世界CPU的特权等级TrustZone的结构CA与TA通信流程 TEE安全设计系统总线设计内存隔离机制安全启动机制安全通信机制 总结 前言 先引用 《可信计算&…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023