AI 助理
文档备案控制台
开发者社区 龙蜥操作系统 文章 正文

Linux基础IO【重定向和缓冲区】

2023-07-21 435
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： Linux基础IO，包括文件描述符的理解，重定向操作，缓冲区介绍等丰富内容，详细讲解，干货满满！

Linux基础IO【重定向和缓冲区】

上文讲解了Linux下的文件操作，本文来接着讲解文件描述符的概念，我们可以利用文件描述符来对标准流进行重定向，使用指定的文件流，以及缓冲区的概念，使用缓冲区进行批量化读取，来提高IO效率

1. 文件描述符

前面讲到了open()函数打开文件成功的返回值就是一个文件描述符，那它到底是什么呢？下面听我一一道来

  • 任何进程在启动的时候都会默认打开三个文件流：标准输入、标准输出、标准错误，对应到C/C++中就是，stdin/cin，stdout/cout，stderr/cerr
  • 这里C语言对应的三个文件语言层面上就是extern FILE* stdin、extern FILE* stdout、extern FILE* stderr

在C语言文件操作时，我们是用FILE*指针来对文件进行操作，那么OS是怎么根据不同的FILE*指针，来找到不同的文件对象的呢？

  • FILE类型的成员中包含了文件描述符fd，就是靠文件描述符来找到不同的FILE对象

我们到来验证一下，在/usr/include/libio.h路径下

我们通过打印来看看标准文件流和自己打开的文件流的fd

#include <stdio.h>

int main()
{
   
  //打开三个FILE对象
  FILE* fp1 = fopen("test1.txt", "w");
  FILE* fp2 = fopen("test2.txt", "w");
  FILE* fp3 = fopen("test3.txt", "w");
  //打印标准文件流
  printf("stdin->fd: %d\n", stdin->_fileno);
  printf("stdout->fd: %d\n", stdout->_fileno);
  printf("stderr->fd: %d\n", stderr->_fileno);
  //打印自己打开的文件流
  printf("fp1->fd: %d\n", fp1->_fileno);
  printf("fp2->fd: %d\n", fp2->_fileno);
  printf("fp3->fd: %d\n", fp3->_fileno);
  //关闭
  fclose(fp1);
  fclose(fp2);
  fclose(fp3);
  return 0;
}

这就验证了FILE中fd的存在，也说明了标准输入流、标准输出流、标准错误流，对应的文件描述符分别为0，1，2

因为默认情况下，标准流占用了前三个fd，所以我们自己新打开的文件，fd是从3开始的

1.1 深度了解文件描述符

文件描述符的产生是OS为了更高效的管理文件系统

  • S依照先描述，再组织的原则开始，将所有的文件都视为file对象，将它们的file*指针存入指针数组fd_array[]中进行统一高效的管理，数组的下标就是文件描述符fd
  • 任何进程在启动的时候都会默认打开三个文件流，将它们的file*存入fd_array数组中，对应的下标就是0，1，2，再新打开的文件的file*对象会被存入数组中未被占用的最小下标处，所以我们自己打开的文件描述符一般都是从3开始的

将文件描述符等文件属性集合起来，就构成了files_struct结构体，而他正是task_struct的成员之一

文件被打开后，不会直接加载到内存中，而是在磁盘中等待进程IO

1.2 文件描述符分配规则

分配规则也就是：在文件描述符数组当中，找到当前没有被使用的最小的一个下标，作为新的文件描述符

我们上面验证过新打开文件的文件描述符从3开始分配，如果我们关闭标准输入流stdin呢？

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

int main()
{
   
    //直接打开文件text.txt
    int fd = open("text.txt", O_WRONLY | O_CREAT | O_TRUNC, 0666);
    printf("text->fd: %d\n", fd);
    close(fd);

    //先关闭标准输入流，再打开文件
    close(0);   //关闭1号文件执行流
    fd = open("text.txt", O_WRONLY | O_CREAT | O_TRUNC, 0666);
    printf("text->fd: %d\n", fd);
    close(fd);

    return 0;
}

这也就验证了上面的分配规则

1.3 深度理解一切皆文件

怎样理解我们常说的Linux下一切皆文件这个说法呢？

  • 驱动程序完成各个设备的输入输出读取数据等操作，各个硬件操作都不一样，文件对象中就有相关操作函数的函数指针来控制不同的设备的各种操作
  • 当我们执行程序时，程序变成了进程，此时进程只会与文件对象进程相对应的联系，并不会管底层的各个设备的操作实现的千差万别，所以说从进程角度来看，一切皆是文件。也就是用户视角来看一切皆是文件。
  • 对于OS来说，硬件软件都是个file对象，只要提供对应的读写方法就可以对其进行驱动，然后将它们的file*存入文件描述符数组中进行管理，所以在Linux下一切皆文件

2. 重定向

OS在进行IO操作时，是根据标准输入，标准输出，标准错误所对应的文件描述符0，1，2来进行操作的，我们将三个标准中的原文件进行替换，就能达到重定向的目的，这就是重定向的本质

三个标准流

  • 标准输入流：从键盘中读取数据，对应键盘文件
  • 标准输出流：将数据输出到显示器，对应显示器文件
  • 标准错误流，将错误信息输出到显示器，对应显示器文件

2.1 重定向操作

==输入重定向==

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

int main()
{
   
  close(0); //close(stdin)  
  int fd = open("file.txt", O_RDONLY);

  int a = 0;
  int b = 0;
  scanf("%d%d\n",&a, &b);
  printf("a = %d, b = %d\n", a, b);

  return 0;
}

首先关闭标准输入流stdin，然后打开文件file.txt，此时文件描述符数组中file.txt的下标就是0，调用scanf()函数对a和b变量赋值，此时本该从键盘读取就重定向成了从file.txt文件读取

==输出重定向==

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

int main()
{
   
  close(1); //close(stdout)  
  int fd = open("file.txt", O_WRONLY | O_CREAT | O_TRUNC, 0664);

  printf("hello world!\n");
  printf("hello world!\n");
  printf("hello world!\n");
  return 0;
}

首先关闭标准输出流stdout，新打开的文件file.txt的下标就取代了1，本该打印到屏幕上的内容打印到了file.txt中

==追加重定向==

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

int main()
{
   
  close(1); //close(stdout)
  int fd = open("file.txt", O_APPEND | O_WRONLY | O_CREAT, 0664);

  printf("hello world!\n");
  printf("hello world!\n");
  printf("hello world!\n");
  return 0;
}

2.2 重定向指令

通过指令完成输出重定向，将数据输出到指定文件

echo 数据 > 文件名

通过指令完成输入重定向，从文件中读取数据

cat < 文件名

通过指令完成追加重定向

echo 数据 >> 文件名

还可以在程序运行后进行重定向

#include <iostream>
using namespace std;

int main()
{
   
    cout << "hello cout" << endl;
    cerr << "hello cerr" << endl;
    return 0;
}

对标准输出重定向，file.txt中只会有来自标准输出流的信息

对标准输出和标准错误都重定向，将数据都打印到file.txt中

通过重定向，将标准输出，标准错误打印到两个不同的文件

2.3 重定向函数

在实际开发中，进行重定向操作时，往往使用函数dup2来执行

int dup2(int oldfd, int newfd)接口

  • 功能：将旧的fd重定向为新的fd
  • oldfd参数：表示新的fd
  • newfd参数：表示旧的fd
  • 重定向完成后newfd改写为oldfd，newfd是oldfd的一份拷贝，最终只是保留了oldfd下标对应的内容
  • 返回值：成功返回新的fd，失败返回-1并适当地设置errno

这个接口的参数设计有些奇怪，大家反向记忆一下

  • 举个例子，新开一个文件，对应的fd为3，现在想将内容输出到这个文件中，也就是实现输出重定向，使用到dup2()接口对应的操作就是dp2(3, 1)

我们可以使用重定向将正常信息和报错信息分别输出到不同的文件

#include <iostream>
#include <cstdlib>
#include <cerrno>
#include <cstring>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
using namespace std;

int main()
{
   
    //打开两个目标文件
    int fd1 = open("file.txt", O_WRONLY | O_CREAT | O_TRUNC, 0666);
    int fd2 = open("error.txt", O_WRONLY | O_CREAT | O_TRUNC, 0666);

    //重定向
    int ret = dup2(fd1, 1); //标准输入重定向到file.txt
    ret = dup2(fd2, 2);     //标准错误重定向到err.txt

    cout << "hello world!" << endl;
    cout << "hello world!" << endl;
    cout << "hello world!" << endl;

    int fd = open("test.txt", O_RDONLY); //打开不存在的文件
    if(fd == -1)
    {
   
        //打印报错信息
           cerr << "open fail! errno: " << errno << endl;
        cerr << "error message: " << strerror(errno) << endl;
        exit(-1);
    }

    close(fd);

    return 0;
}

3. 缓冲区

3.1 缓冲区理解

先来举个例子帮助理解缓冲区

  • 假如你家养了一只小狗，你在给它喂食时每次都只能往他嘴里丢入几粒狗粮，这一来喂食的时间就特别长，效率很低，于是你想了个办法，给他买了个饭碗，每次只用将狗粮倒入碗中，等它自己来进食即可，这样就大大提高了效率，而这个饭碗就是缓冲区

缓冲区就本质就是一个buffer数组，配合不同的刷新策略，起到提高IO效率的作用

  • 众所周知CPU的计算速度是非常快的，与其相比磁盘的读取是速度是特别慢的，CPU日理万机可等不起磁盘，于是就有了缓冲区，先将数据写入到缓冲区中，再根据不同的刷新策略，将数据刷新到内核缓冲区中，供CPU使用，这样就可以起到提高效率，节省调用者时间的作用

我们来看看有无IO的情况下CPU的算力

#include <iostream>
#include <unistd.h>
#include <signal.h>
using namespace std;

int count = 0;

int main()
{
   
    //定一个1秒的闹钟
    alarm(1);
    while(true)
    {
   
        cout << count++ << endl;
    }
    return 0;
}

有IO的情况下，差不多跑了11W+次

#include <iostream>
#include <unistd.h>
#include <signal.h>
using namespace std;

int count = 0;
void Print(int signo)
{
   
    cout << "count: " << count << endl;
    exit(1);
}

int main()
{
   
    //定一个1秒的闹钟
    signal(14, Print);
    alarm(1);
    while(true) count++;
    return 0;
}

去掉IO，差不多跑了5亿+次，可见频繁的IO对CPU的计算影响是很大的，如果没有缓冲区，还要花费更多时间在IO上

常常利用缓冲区进程读取/写入操作

#include <iostream>
#include <cassert>
#include <cstdio>
#include <cstring>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
using namespace std;

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

    char buffer[256] = {
    0 };   //缓冲区
    int n = read(0, buffer, sizeof(buffer));   //从标准输入读取数据到缓冲区中
    buffer[n] = '\0';

    //再将缓冲区中数据写入文件中
    write(fd, buffer, strlen(buffer));

    close(fd);
    return 0;
}

3.2 缓冲区刷新策略

缓冲区有三种刷新策略

  • 无缓冲：不会刷新到缓冲区中，而是直接给操作系统
  • 行缓冲：遇到\n停止刷新，一次冲刷一行
  • 全缓冲：只有缓冲区写满了才进行刷新

一般显示器的刷新策略为行缓冲，普通文件的刷新策略为全缓冲

来观察一下

#include <iostream>
#include <unistd.h>
using namespace std;

int main()
{
   
    while(true)
    {
   
        printf("%s\n", "happy"); //如果不加'\n'就是全缓冲，缓冲区满了才会刷新
        sleep(1);
    }
    return 0;
}

image-20230721195124344

每秒打印一次

小结

  • 不发生刷新的本质是不调用系统调用，并没有刷新到文件中，而是放在了对应的FILE结构体中的缓冲区中，因此，fwrite()函数调用会非常快
  • 可以在缓冲区中挤压多份数据，随后统一进行刷新。本质：一次IO可以IO更多的数据，提高IO效率
  • fflush刷新的本质就是将结构体中的缓冲区也就是用户缓冲区中的数据通过系统调用接口写入到操作系统

3.3 倒计时和进度条小程序

\r是回车，光标跳转到所在行最开始的位置，\n是换行

根据缓冲区的规则来实现两个简单的小程序

倒计时小程序

#include <unistd.h>
#include <stdio.h>

int main()
{
   
  int i = 0;
  for(; i >= 0; i--)
  {
   
    printf("%2d\r",i);
    fflush(stdout);
    sleep(1);
  }
  printf("\n");
  return 0;
}

进度条小程序

#include <stdio.h>
#include <string.h>
#include <unistd.h>

#define SIZE 101 //100个字符，加字符串结束标志'\0'
#define STYLE '#'

void process()
{
   
  const char* clockWise = "|/-\\";
  char buf[SIZE];
  memset(buf, '\0', sizeof(buf));
  int i = 0;
  while(i <= 100)
  {
   
    printf("[%-100s][%d%%][%c]\r",buf, i, clockWise[i%4]);
    fflush(stdout); //刷新缓冲区
    buf[i++] = STYLE;
    usleep(100000); //usleep单位是微秒，这里就是0.1微秒
  }
  printf("\n");
}

int main()
{
   
  process();
  return 0;
}

3.4 内核级缓冲区

内核级缓冲区理解

  • 每个file对象都有自己的缓冲区和刷新策略，在系统中还有一个内核级缓冲区，它是CPU真正进行IO的地方
  • 进行IO时，先将普通缓冲区中的数据刷新至内核级缓冲区中，CPU 再从内核级缓冲区中取数据进行运算，然后存回内核级缓冲区中，最后再由内核级缓冲区冲刷给普通缓冲区

来看一个现象

#include <stdio.h>
#include <unistd.h>
#include <string.h>

int main()
{
   
  fprintf(stdout, "hello world!\n");
  const char* message = "Are you OK?\n";
  write(1, message, strlen(message));

  fork(); //创建子进程

  return 0;
}

image-20230721214417827

这里我们发现在重定向后输出了两条hello wordl！这是为什么呢？

  • 显示器刷新策略为行缓冲，普通文件为全缓冲
  • 直接运行程序是向显示器中打印内容，因为有\n，所以两条语句都直接进行了冲刷
  • fprintf使用的是C语言库中对应的缓冲区，fork创建子进程后，会再拷贝一份代码给子进程，父子进程的fprintf缓冲区中都有内容，因为普通文件是全缓冲策略，当程序运行结束后，会统一刷新，于是就是打印了两条hello wordl！

补充：系统级接口没有自己的缓冲区，会直接冲刷至内核级缓冲区中，比如上面的write是直接写入到文件缓冲区的，并不会通过C语言库缓冲区再到文件缓冲区的，所以创建子进程对write的冲刷没有任何影响

4. 模拟实现C语言文件流

C语言文件流的FILE结构体类型，包含了文件的很多属性以及文件描述符fd等，以此为基础实现了C语言文件相关操作，如fopen、fclose、fwrite、fread等，这些函数本质上都是对系统调用的封装，我们可以根据系统调用和上面的缓冲区相关知识，模拟实现一个简单的C语言文件流

实现源码

mystdio.h

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

#define N 1024
#define BUFFER_NONE 0x1
#define BUFFER_LINE 0x2 //行缓冲
#define BUFFER_ALL  0x4 //全缓冲

typedef struct MY_FILE
{
   
  int fileDescriptor;
  char outputBuffer[N];
  int flags; //刷新方式
  int current; //写入位置
}MY_FILE;

MY_FILE* my_fopen(const char* path, const char* mode); //对应的是fopen()-c接口
size_t my_fwrite(const void* ptr, size_t size, size_t nmemb, MY_FILE* stream); //对应的是fwrite()-c接口
int my_fclose(MY_FILE* fp); //对应的是fclose()-c接口

mystdio.c

#include "mystdio.h"

int my_fflush(MY_FILE* fp)
{
   
  assert(fp);
  write(fp->fileDescriptor, fp->outputBuffer, fp->current);
  fp->current = 0;
  fsync(fp->fileDescriptor); //同步文件的核内状态到存储设备
  return 0;
}

MY_FILE* my_fopen(const char* path, const char* mode) //对应的是fopen()-c接口
{
   
  //1.辨别打开模式
  int flag = 0;
  if(strcmp(mode, "r") == 0) flag |= O_RDONLY;
  else if(strcmp(mode, "w") == 0) flag |= (O_WRONLY | O_CREAT | O_TRUNC);
  else if(strcmp(mode, "a") == 0) flag |= (O_WRONLY | O_CREAT | O_APPEND);
  // 其他方式就不列举

  //2.设置默认mode
  mode_t m = 0664;

  //3.调用open()系统调
  int fd = 0;
  if(flag & O_CREAT) fd = open(path, flag, m);
  else fd = open(path, flag);

  //4.调用open()失败
  if(fd < 0) return NULL;

  //5.调用open()成功返回MY_FILE结构体指针
  MY_FILE* my_file = (MY_FILE*)malloc(sizeof(MY_FILE));
  if(my_file == NULL) //调用malloc()失败
  {
   
    close(fd); //关闭文件防止对后续操作受影响
    return NULL;
  } 
  my_file->fileDescriptor = fd;
  my_file->flags = 0;
  my_file->flags |= BUFFER_LINE; //默认采用行刷新
  my_file->current = 0;
  memset(my_file->outputBuffer, '\0', sizeof(my_file->outputBuffer));
  return my_file;
}

size_t my_fwrite(const void* ptr, size_t size, size_t nmemb, MY_FILE* stream)
{
   
  //1. 缓冲区已满直接写入 
  if(stream->current == N) my_fflush(stream); 

  //2. 缓冲区未满，数据拷贝，更新写入位置
  size_t fill_sz = size * nmemb;
  size_t have_sz = N - stream->current;
  size_t write_sz = 0;
  if(have_sz >= fill_sz) 
  {
   
    memcpy(stream->outputBuffer + stream->current, ptr, fill_sz);
    stream->current += fill_sz;
    write_sz = fill_sz;
  }
  else 
  {
   
    memcpy(stream->outputBuffer + stream->current, ptr, have_sz);
    stream->current += have_sz;
    write_sz = have_sz;
  }

  //3. 刷新
  if(stream->flags & BUFFER_LINE) 
  {
   
    if((stream->outputBuffer[stream->current - 1]) == '\n') my_fflush(stream);
  }
  else if(stream->flags & BUFFER_ALL) 
  {
   
    if(stream->current == N) my_fflush(stream);
  } 
  return write_sz;
}

int my_fclose(MY_FILE* fp)
{
   
  assert(fp);
  //1. 刷新缓冲区
  if(fp->current > 0) my_fflush(fp); 

  //2. 关闭文件
  close(fp->fileDescriptor);

  //3. 释放空间
  free(fp);
  fp = NULL;
  return 0; //操作成功
}

main.c

#include "mystdio.h"

int main()
{
   
  MY_FILE* fp = my_fopen("log.txt", "w");
  if(fp == NULL) exit(1);

  const char* message = "hello linux";

  int cnt = 5;
  while(cnt--)
  {
   
    char buffer[1024];
    snprintf(buffer, sizeof(buffer), "%s, %d\n", message, cnt);
    size_t size = my_fwrite(buffer, strlen(buffer), 1, fp);
    sleep(1);
    printf("当前成功写入: %zd个字节\n", size);
  }

  my_fclose(fp);

  return 0;
}

Linux基础IO【重定向和缓冲区】，到这里就介绍结束了，本篇文章对你由帮助的话，期待大佬们的三连，你们的支持是我最大的动力！

文章有写的不足或是错误的地方，欢迎评论或私信指出，我会在第一时间改正

文章标签：
龙蜥操作系统
C++
C语言
Linux
小程序
关键词：
Linux IO
Linux重定向
Linux缓冲区
io重定向
Linux io缓冲区
诚酱
目录
相关文章
石小浪♪
|
存储 Linux C语言
Linux C/C++之IO多路复用(aio)
这篇文章介绍了Linux中IO多路复用技术epoll和异步IO技术aio的区别、执行过程、编程模型以及具体的编程实现方式。
石小浪♪
907 1
Linux C/C++之IO多路复用(aio)
蓝易云
|
监控 Linux
Linux命令大全：echo与tail实现输出重定向。
这样，我们实现了使用echo和tail命令进行输出重定向的目的。在实际应用中，输出重定向技巧可节省时间，提高工作效率。希望本文内容对您了解和掌握Linux系统中echo与tail命令以及输出重定向的操作有所帮助。
蓝易云
415 27
蓝易云
|
存储 网络协议 Linux
【Linux】进程IO|系统调用|open|write|文件描述符fd|封装|理解一切皆文件
本文详细介绍了Linux中的进程IO与系统调用，包括 `open`、`write`、`read`和 `close`函数及其用法，解释了文件描述符（fd）的概念，并深入探讨了Linux中的“一切皆文件”思想。这种设计极大地简化了系统编程，使得处理不同类型的IO设备变得更加一致和简单。通过本文的学习，您应该能够更好地理解和应用Linux中的进程IO操作，提高系统编程的效率和能力。
蓝易云
742 34
hahaha无
|
Linux C语言 网络架构
Linux的基础IO内容补充-FILE
而当我们将运行结果重定向到log.txt文件时，数据的刷新策略就变为了全缓冲，此时我们使用printf和fwrite函数打印的数据都打印到了C语言自带的缓冲区当中，之后当我们使用fork函数创建子进程时，由于进程间具有独立性，而之后当父进程或是子进程对要刷新缓冲区内容时，本质就是对父子进程共享的数据进行了修改，此时就需要对数据进行写时拷贝，至此缓冲区当中的数据就变成了两份，一份父进程的，一份子进程的，所以重定向到log.txt文件当中printf和fwrite函数打印的数据就有两份。此时我们就可以知道，
hahaha无
394 0
hahaha无
|
存储 Linux Shell
Linux的基础IO
那么，这里我们温习一下操作系统的概念我们在Linux平台下运行C代码时，C库函数就是对Linux系统调用接口进行的封装，在Windows平台下运行C代码时，C库函数就是对Windows系统调用接口进行的封装，这样做使得语言有了跨平台性，也方便进行二次开发。这就是因为在根本上操作系统确实像银行一样，并不完全信任用户程序，因为直接开放底层资源（如内存、磁盘、硬件访问权限）给用户程序会带来巨大的风险。所以就向银行一样他的服务是由工作人员隔着一层玻璃，然后对顾客进行服务的。
hahaha无
182 0
蓝易云
|
Linux API C语言
Linux基础IO
Linux基础IO操作是系统管理和开发的基本技能。通过掌握文件描述符、重定向与管道、性能分析工具、文件系统操作以及网络IO命令等内容，可以更高效地进行系统操作和脚本编写。希望本文提供的知识和示例能帮助读者更深入地理解和运用Linux IO操作。
蓝易云
357 14
wljslmz
|
存储 缓存 固态存储
如何在 Linux 中清除缓冲区和缓存内存？
【10月更文挑战第7天】
wljslmz
1096 0
如何在 Linux 中清除缓冲区和缓存内存？
热爱技术的小郑
|
存储 Java
【IO面试题 四】、介绍一下Java的序列化与反序列化
Java的序列化与反序列化允许对象通过实现Serializable接口转换成字节序列并存储或传输，之后可以通过ObjectInputStream和ObjectOutputStream的方法将这些字节序列恢复成对象。
热爱技术的小郑
478 2
凉凉心.
|
9月前
|
Java Unix Go
【Java】（8）Stream流、文件File相关操作，IO的含义与运用
Java 为 I/O 提供了强大的而灵活的支持，使其更广泛地应用到文件传输和网络编程中。！但本节讲述最基本的和流与 I/O 相关的功能。我们将通过一个个例子来学习这些功能。
凉凉心.
337 1

龙蜥操作系统

热门文章

最新文章

  • 1
    python 第一天
  • 2
    当 AI 从“对话”走向“协作”，谁来管理百万级 Token 的工作记忆？
  • 3
    龙蜥操作系统：CentOS 谢幕之后，国产云原生系统的崛起之路
  • 4
    产品推荐：多核性能比上一代提升 28%，怎么做到的？Alibaba Cloud Linux 4 性能全解析
  • 5
    E2000 UEFI使用设备树方式启动linux系统
  • 6
    阿里云AUG | 当 Agent 成为云的新用户：一场关于"安全账 + 成本账"的 30 人闭门局
  • 7
    从指令到生态：这场 MeetUp 看 RISC-V 编译器如何成为“芯”时代的超级枢纽
  • 8
    Linux版百度网盘丨直接在服务器SSH命令行中使用百度云，轻松解决数据传输和分享难题
  • 9
    查看linux操作系统版本：Ubuntu？Centos？还是其他？
  • 10
    新征程！龙蜥社区捐赠给开放原子开源基金会，全面升级为“AI 原生操作系统社区”
  • 1
    阿里云AUG | 当 Agent 成为云的新用户：一场关于"安全账 + 成本账"的 30 人闭门局
    65
  • 2
    首次！龙蜥社区联合清华、阿里云、江波龙提出CXL保护型键值存储架构，仅引入微量开销
    49
  • 3
    龙蜥与玄铁共建 RISC-V 编译器生态：五大 GCC 优化实践解法
    40
  • 4
    龙蜥社区第 42 次运营委员会会议圆满结束
    38
  • 5
    开源活动推荐：青年开源专项基金种子计划来了，欢迎报名
    42
  • 6
    产品推荐：多核性能比上一代提升 28%，怎么做到的？Alibaba Cloud Linux 4 性能全解析
    144
  • 7
    「Skill 创造营」—— 龙蜥 SkillHub 技能与最佳实践征集
    90
  • 8
    开源项目推荐：你在用 Hermes？它也能拥有 ANOLISA 全套能力了
    96
  • 9
    从指令到生态：这场 MeetUp 看 RISC-V 编译器如何成为“芯”时代的超级枢纽
    114
  • 10
    从龙蜥孵化到上游贡献：SGLang Tracing 与 AI Agent 调优实践
    115

    • 相关课程

    更多
  • Linux MySQL服务器搭建与应用
  • Linux用户和组管理
  • Linux服务器运维基本操作
  • Linux企业运维实战 - 入门及常用命令
  • Linux Shell 编程入门与实战
  • Linux网络进阶 - TCP/IP协议及OSI七层模型

    • 相关电子书

    更多
  • Alibaba Cloud Linux 3 发布
  • ECS系统指南之Linux系统诊断
  • ECS运维指南 之 Linux系统诊断

    • 推荐镜像

    更多
  • mxlinux-iso
  • archlinuxarm
  • archlinuxcn
    • 下一篇
    一条命令迁移，帮你实现 OpenClaw 与 Hermes Agent 记忆互通！