IO进程（标准IO）

原创 已于 2024-04-11 18:39:47 修改 · 979 阅读 · 27 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#linux #c语言

于 2024-04-10 19:34:18 首次发布
本文围绕Linux下C语言标准IO展开，介绍了标准IO的概念、特点，阐述了全缓存、行缓存和不缓存三种缓存区类型。详细讲解了标准IO的函数接口，包括文件的打开、关闭、读写操作及其他操作，如重定向流和文件定位等，还给出了相关练习及思路。

大纲

IO：input、output

标准IO

文件IO

文件属性获取

目录操作

库

进程：process

进程基础

线程(thread)、同步、互斥、条件变量

进程间通信：6种（一共有7种）

无名管道(pipe)、有名管道(fifo)、信号（signal）、共享内存(shared memory)、信号灯集(semphore set)、消息队列（message queue）

标准IO

1.什么是标准IO？

1.1 概念

标准IO：是在C库中定义的一组专门用于输入输出的函数。

1.2 特点

1.通过缓冲机制减少系统调用，提高效率。

系统调用：是内核向上提供的一组接口

例如：从硬盘循环读1KB文件，每次读1B

2.围绕流进行操作，流用FILE *来描述

注意: vi用ctags索引使用：

1）vi -t 查找名称

输入前面序号，回车。

2）继续追踪：

将光标定位到要追踪的内容，ctrl+]

回退：ctrl+t

3）跳转到上次位置：ctrl+o

      跳转到下次位置：ctrl+i

3.标准IO默认打开三个流，stdin(标准输入) stdout(标准输出) stderr(标准错误)

2.缓存区

  1. 全缓存：和文件相关的
  2. 行缓存：和终端相关的

刷新标准输出缓存区的条件：

  • \n
  • 程序正常退出
  • 缓存区满
  • 强制刷新：fflush(NULL)
#include <stdio.h>

int main(int argc, char const *argv[])
{
    //printf("hello world\n"); //\n不光可以换行，还可以刷新标准输出的缓冲区
    printf("hello world");
    fflush(NULL); //强制刷新缓存区
    while (1);
    return 0;  //正常退出刷新刷存区
}

     3.不缓存：没有缓存，标准错误。

综上：当我们每次要打印数据时，并不是将数据直接发送给标准输出设备，也就是并直接发送给显示器，而是将要打印的数据先存放到缓存区，当缓冲存数据满时，或者遇到\n，或者程序结束时，或者手动刷新缓存区时，缓冲区才会把数据传输到标准输出设备中，也就是显示器中进行输出。

例子：

#include <stdio.h>

int main()
{
    printf("hello");
    while(1);
    
    return 0;
}

结果是：不输出hello，什么也没有输出

因为：没有刷新缓冲区，只有刷新缓冲区的时候，缓冲区才会把数据传输到标准输出设备中

练习：计算标准输出的缓存区大小 

方法一：利用循环打印展示

方法二：利用结构体指针stdout

#include <stdio.h>

int main(int argc, char const *argv[])
{
    printf("buf:"); //不进行输出的话缓存去不会开辟，所以需要开辟缓存区的话需要先调用标准输出函数。
    printf("%d\n",stdout->_IO_buf_end - stdout->_IO_buf_base);
    return 0;
}

得到1024B=1KB

3.函数接口

3.1 打开文件 fopen

FILE *fopen(const char *path, const char *mode);

功能：打开文件

参数：

    path：打开的文件路径

    mode：打开的方式

        r：只读，当文件不存在时报错，文件流定位到文件开头

        r+：可读可写，当文件不存在时报错，文件流定位到文件开头

        w：只写，文件不存在创建，存在则清空

        w+：可读可写，文件不存在创建，存在则清空

        a：追加(在末尾写),文件不存在创建，存在追加，文件流定位到文件末尾

        a+：读和追加，文件不存在创建，存在追加，读文件流定位到文件开头，写文件流定位到文件末尾

注：当a+的方式打开文件时，写只能在末尾进行追加，定位操作是无法改变写的位置，但是可以改变读的位置

返回值：

成功：文件流

失败：NULL，并且会设置错误码

3.2 关闭文件

int fclose(FILE* stream);

功能：关闭文件

参数：stream：文件流

#include <stdio.h>

int main(int argc, char const *argv[])
{
    FILE *fp;
    //1.打开文件
    //fp = fopen("test.txt","w");
    fp = fopen("test.txt", "r");
    if (NULL == fp)
    {
        perror("fopen err"); //如果以r方式打开，没有这个文件会报错，打印错误信息。
        return -1;
    }
    printf("fopen success\n");

    //2. 关闭文件
    fclose(fp);

    return 0;
}

3.3 文件读写操作

3.3.1 每次读写一个字符：fgetc()、fputc()

每次读一个字符fgetc()

int fgetc(FILE * stream);

功能：从文件中读取一个字符,并将当前文件指针位置向后移动一个字符。

参数：stream：文件流

返回值：成功：读到的字符

       失败或读到文件末尾：EOF(-1)

每次写一个字符fputc()

int fputc(int c, FILE * stream);

功能：向文件中写入一个字符, 成功写入后文件指针会自动向后移动一个字节位置。

参数：c：要写的字符

      stream：文件流

返回值：成功：写的字符的ASCII

       失败：EOF(-1)

（1）针对文件

#include <stdio.h>

int main(int argc, char const *argv[])
{
    FILE *fp;
    //1.打开文件
    fp = fopen("test.txt", "r+");
    //fp = fopen("test.txt", "r");
    if (NULL == fp)
    {
        perror("fopen err"); //如果以r方式打开，没有这个文件会报错，打印错误信息。
        return -1;
    }
    printf("fopen success\n");

    //对文件读写操作
    char ch = fgetc(fp); //test.txt的文件内容是hello
    printf("%c %d\n", ch, ch);//h 104

    ch = fgetc(fp);
    printf("%c %d\n", ch, ch);//e 101

    fputc('a', fp);
    fputc(98, fp);

    //2. 关闭文件
    fclose(fp);

    return 0;
}

（2）针对终端

#include <stdio.h>

int main(int argc, char const *argv[])
{
    char ch = fgetc(stdin);
    //printf("%d %c\n", ch, ch);
    fputc(ch, stdout);

    ch = fgetc(stdin);
    //printf("%d %c\n", ch, ch);
    fputc(ch, stdout);

    return 0;
}

补充：feof和ferror

int feof(FILE * stream);

功能：判断文件有没有到结尾，也就是当前所在位置后面还有没有字符。

返回：如果到达文件末尾，返回非零值。如果后面还有字符则返回0。

#include <stdio.h>

int main(int argc, char const *argv[])
{
    FILE *fp;
    //打开文件
    //fp = fopen("test.txt", "w"); //只写，文件不存在创建，存在则清空
    //fp = fopen("test.txt","r"); //只读，当文件不存在时报错，文件流定位到文件开头
    fp = fopen("test.txt","r+"); 
    if (NULL == fp)
    {
        perror("fopen err");
        return -1;
    }
    printf("fopen success\n");

    //对文件读写操作
    char ch = fgetc(fp);
    printf("%c %d\n",ch, ch); //h 104
    ch = fgetc(fp);
    printf("%c %d\n",ch, ch); //e 101

    fputc('w', fp);
    fputc('s', fp); //hewso

    //判断末尾
    ch = fgetc(fp);
    printf("%c %d\n",ch, ch); //o 111
    ch = fgetc(fp);
    printf("%c %d\n",ch, ch); //? -1
    if(feof(fp))
    {
        printf("end\n"); //-1之后才是末尾
    }

    //关闭文件
    fclose(fp);
    
    return 0;
}

int ferror(FILE * stream);

功能:检测文件有没有出错

返回：文件出错，返回非零值。如果没有出错，返回0。

#include <stdio.h>

int main(int argc, char const *argv[])
{
    FILE *fp;
    //1.打开文件
    fp = fopen("test.txt", "w");
    if (NULL == fp)
    {
        perror("fopen err"); 
        return -1;
    }
    printf("fopen success\n");

    char ch = fgetc(fp); //因为权限是只写，所以读操作有错误。
    if (ferror(fp))
    {
        printf("err!\n");
        return -1;
    }

    fclose(fp);

    return 0;
}

练习：cat 文件名

./a.out 文件名

步骤：

  1. 打开文件
  2. 循环fgetc读文件内容
  3. 当读到文件末尾EOF时结束
  4. 将读到内容用fputc打印到终端
  5. 关闭文件
#include <stdio.h>

//实现cat功能  将一个文件的内容打印到终端上
int main(int argc, char const *argv[])
{
    //判断
    if (argc != 2)
    {
        printf("format: %s <filename>\n", argv[0]);
        return -1;
    }
    //打开文件
    FILE *fp;
    fp = fopen(argv[1], "r");
    if (NULL == fp)
    {
        perror("fopen err");
        return -1;
    }
    char ch;
    //循环读文件
    while (!feof(fp))
    {
        fputc(ch, stdout);
    }
    //关闭文件
    fclose(fp);

    return 0;
}

3.3.2 每次一串字符的读写 fgets() 和 fputs()

char * fgets(char *s, int size,  FILE * stream);

功能：从文件中每次读取一行字符串

参数：    s：存放字符串的地址

           size：期望一次读取的字符个数

         stream：文件流

返回值：成功：s的地址

       失败或读到文件末尾：NULL

特性：  每次实际读取的字符个数为size-1个，会在末尾自动添加\0

       每次读一行，遇到\n或者到达文件末尾后不再继续读下一行

       并把它存储在s所指向的字符串内。

int fputs(const char *s,  FILE * stream);

功能：向文件中写字符串

参数：s：要写的内容

     stream：文件流

返回值：成功：非负整数

       失败：EOF

（1）针对终端

注意： fgets输入时最后一定有一个位置给\0

（2）针对文件

练习：通过fgets实现"wc -l 文件名"命令功能（计算文件行数）

思路：打开文件，循环读文件fgets(buf,32,fp)；只要有\n就len++

//实现 wc -l //将文件的行数打印到终端上
#include <stdio.h>
#include <string.h>

int main(int argc, char const *argv[])
{
    char buf[55] = "";
    int len = 0;
    if (argc != 2) //如果命令数不是2，执行
    {
        printf("format: %s <filename>\n", argv[0]);
        return -1;
    }
    FILE *fp = fopen(argv[1], "r");
    if (NULL == fp)
    {
        perror("fopen err");
        return -1;
    }

    while (fgets(buf, 55, fp)) //读到末尾结束
    {
        if(buf[strlen(buf)-1] == '\n') //判断最后一个字符是不是“\n”
            ++len;
    }
    printf("%d %s\n", len, argv[1]);
    return 0;
}

练习：使用C语言编写一段程序，实现从1开始以每秒累加1的方式向文件中写入数字，写到100后停止。要求代码格式规范，输出结果清晰易懂。

//练习：使用C语言编写一段程序，实现从1开始以每秒累加1的方式向文件中
//写入数字，写到100后停止。要求代码格式规范，输出结果清晰易懂。
//sleep(1);

#include <stdio.h>
#include <unistd.h> //sleep函数的头文件
#include <string.h>

int main(int argc, char const *argv[])
{
    FILE *fp = fopen("test.txt", "a+");
    if (NULL == fp)
    {
        perror("fopen err");
        return -1;
    }
    int len = 0;
    char buf[55] = "";
    //计算行数
    while (fgets(buf, 55, fp))
    {
        if(buf[strlen(buf)-1] == '\n')
            ++len;
    }
    //写入数字
    while (len != 100)
    {
        fprintf(fp, "%d\n", ++len);
        fflush(NULL);
        sleep(1); //睡眠1s
    }
    fclose(fp);

    return 0;
}

练习：

题目要求：编程读写一个文件test.txt，每隔1秒向文件中写入一行录入时间的数据，类似这样： 

1,  2007-7-30 15:16:42  

2,  2007-7-30 15:16:43

该程序应该无限循环，直到按Ctrl-C中断程序。

再次启动程序写文件时可以追加到原文件之后，并且序号能够接续上次的序号，比如： 

1,  2007-7-30 15:16:42

2,  2007-7-30 15:16:43

3,  2007-7-30 15:19:02

4,  2007-7-30 15:19:03

5,  2007-7-30 15:19:04

思路：

  1. 打开文件fopen，循环往文件写内容
  2. 每隔1s写入一行，sleep(1);
  3. 计算文件行数,wc -l
  4. 计算当前时间，转换成年月日、时分秒，time，localtime

man 2 time

time_t time(time_t *t);

如果t是空指针，直接返回当前时间。如果t不是空指针，返回当前时间的同时，将返回值赋予t指向的内存空间。

  1. 字符串拼接函数：strcpy/strcat(dest, src)、sprintf、fprintf

fprintf：

格式化输出到流（stream）文件中，返回值是输出的字符数,发生错误时返回一个负值.

 int fprintf( FILE *stream, const char *format, ... );

sprintf：

格式化输出发送到buffer(缓冲区)中.返回值是写入的字符数量.

 int sprintf( char *buffer, const char *format, ... );

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

int main(int argc, char const *argv[])
{
    int no = 1;
    char buf[55] = "";
    time_t tim;
    struct tm *t = localtime(&tim);
    
    //打开文件
    FILE *fp = fopen("hw.txt", "a+");
    if (NULL == fp)
    {
        perror("fopen err");
        return -1;
    }
    //判断序号
    while(fgets(buf,55,fp))
    {
        if(buf[strlen(buf)-1] == '\n')
            ++no;
    }
    //写入时间
    while(1)
    {
        tim = time(NULL); //获取当前系统时间
        t = localtime(&tim); //转化为当地时间
        fprintf(fp, "%3d.%d-%d-%d %d:%d:%d\n", no++, t->tm_year + 1900, t->tm_mon + 1, t->tm_mday, t->tm_hour, t->tm_min, t->tm_sec);
        fflush(NULL);
        sleep(1);
    }
    //关闭文件
    fclose(fp);

    return 0;
}

3.3.3 二进制读写fread()和fwrite()

size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream);

功能：从文件流读取多个元素(将二进制数据从文件读出)

参数：  ptr ：是一个指针，是存放数据的存储空间的起始地址，用来存放读取元素

       size ：元素大小  sizeof(元素数据类型)

       nmemb ：读取元素的个数

       stream ：要读取的文件流

返回值：成功：读取的元素的个数

       读到文件尾或失败： 0

size_t fwrite(const void *ptr, size_t size, size_t nmemb,

              FILE *stream);

功能：将二进制数据写入文件

参数： ptr ：是一个指针，保存要输出数据的空间的地址。

     size ：要写入的字节数 sizeof(数据类型)

     nmemb : 要进行写入元素的个数

      strem: 目标文件流指针

返回值：成功：写的元素个数

              失败 ：-1

#include <stdio.h>

int main(int argc, char const *argv[])
{
    float arr[3] = {1.2, 3.4, 5.6};
    float data[3] = {};

    FILE *fp = fopen(argv[1], "r+");
    if (NULL == fp)
    {
        perror("fopen err");
        return -1;
    }
    fwrite(arr, sizeof(float), 3, fp);

    //定位操作
    rewind(fp); //将位置指针定位到文件开头，不然是接着上一步写的位置继续读的，由于是末尾所以读不到东西。

    fread(data, 4, 3, fp);

    printf("%f %f %f\n", data[0], data[1], data[2]);

    return 0;

文件定位到开头：rewind(fp);

 

3.4 其他操作

3.4.1 重定向流到指定文件freopen

FILE * freopen(const char *pathname, const char *mode,  FILE* fp);

功能：将指定的文件流重定向到打开的文件中

参数：path：文件路径

     mode：打开文件的方式（同fopen）

     fp：文件流指针

返回值：成功：返回文件流指针

      失败：NULL

#include <stdio.h>

int main(int argc, char const *argv[])
{
    printf("hello\n");
    //将标准输出重定向到打开的test.txt中
    freopen("test.txt", "w+", stdout);
    printf("world\n");

    //将标准输出流重定向到终端文件/dev/tty
    freopen("/dev/tty", "r+", stdout);
    printf("66666\n");

    return 0;
}
3.4.2 文件定位操作

 

void rewind(FILE *stream);

功能：将文件位置指针定位到起始位置

int fseek(FILE *stream, long offset, int whence);

功能:文件的定位操作

参数：stream：文件流

     offset：偏移量：正数表示向后文件尾部偏移，负数表示向文件开头偏移

     whence：相对位置：

SEEK_SET:相对于文件开头

SEEK_CUR:相对于文件当前位置

SEEK_END:相对于文件末尾

返回值：成功：0

       失败：-1

注：当打开文件的方式为a或a+时，fseek不起作用    

补充：其中SEEK_SET,SEEK_CUR和SEEK_END和依次为0，1和2.

例子：

把fp指针移动到离文件开头100字节处：fseek(fp,100,0);

把fp指针移动到离文件当前位置100字节处:fseek(fp,100,1);

把fp指针退回到离文件结尾100字节处: fseek(fp,-100,2);

long ftell(FILE *stream);

功能：获取当前的文件位置

参数：要检测的文件流

返回值：成功：当前的文件位置，出错：-1

#include <stdio.h>

int main(int argc, char const *argv[])
{
    //fseek 文件定位操作
    //ftell 获取文件的当前指针位置
    FILE *fp = fopen("t1.txt", "w+");
    if (NULL == fp)
    {
        perror("fopen err");
        return -1;
    }
    //定位到文件开头往后10个位置
    fseek(fp, 10, 0);
    fputc('a', fp);
    //定位到相对于当前位置往后5个单位
    fseek(fp, 5, 1);
    fputs("hello", fp);
    //相对于最后位置往前1个单位
    fseek(fp, -1, 2);
    fputc('b', fp);

    //文件指针当前所在位置
    long l = ftell(fp);
    printf("%ld\n", l);



    return 0;
}

1.想对一个文本文件的尾部追加写入，应当在fopen何中使用的文件操作方式指示符号为 ()

A.r     B.w     C. a     D.w+

2.fseek(1, 2, 3);  这个函数是什么作用，三个参数分别是什么意思？

3.函数调用语句:fseek (fp，-10L，2);的含义是

A 将文件位置指针从文件未尾处向文件头的方向移动10个字节

B 将文件位置指针从当前位置向文件头的方向移动10个字节

C 将文件位置指针从当前位置向文件未尾方向移动10个字节

总结：

为什么用标准IO？

1.因为读写文件通常是大量的数据（相对于底层驱动的系统调用所实现的数据操作单位），这时，使用库函数可以大大减少系统调用的次数。

2.为了保证可移植性

 

 

Crazy Leaf
关注
【IO进程】文件IO
colorfulshark
03-29 899
【1】文件IO必须使用操作系统提供输入输出函数来实现文件的读写、定位操作，不能在其他的系统中使用。 文件描述符： 实际上是一个非负的整形数据，文件指针是文件描述的一个软连接 最大数据：0 ~ 1023 打开得文件袋描述符的个数是1024个 无缓冲： 文件IO对比标准IO：标准IO通过对常规文件进行操作，文件IO通常对特殊文件记性操作；文件IO也可以对常规文件
【IO进程】标准IO
colorfulshark
03-27 841
IO针对文件来进行操作， 在linux系统当中几乎所有东西被看做是一个文件来处理文件： 一部分功能就是用来对数据进行存储，常用的文本数据、还有二进制数据 特殊文件是帮助用户站到内存中某一个对象，或者找到对应的设备文件文件的名字： 类型： bcd-lsp 类型 符号 作用 常规文件 - 它用来存储文本数据、还有二进制数据 设备文件 bc 对硬件
学习记录——day20 IO fopen fclose fgets fputs fgetc fputc 错误码 缓存区
最新发布
weixin_64918301的博客
07-26 949
1、IO：（inout output） 程序与外部设备进行信息交换的过程2、IO的分类：标准IO和文件IO1）标准IO：调用封装好的相关库函数，来实现数据的输入输出2）文件IO：3、文件IO和标准IO的区别：1）标准IO属于库函数，文件IO属于系统调用2）标准IO操作的是文件指针，文件IO操作的是文件描述符4、阻塞IO和非阻塞IO5、目前所接触过的IO函数：6、常用的IO接口函数。
IO进程(进程Process)
xcinop的博客
04-15 1535
进程和程序的区别11。
IO进程知识点
weixin_69412780的博客
10-01 432
IO进程函数知识点
精选资源
华清远见嵌入式学习-IO进程线程-作业5
11-09
华清远见嵌入式学习-IO进程线程-作业5 本资源摘要信息涵盖了嵌入式系统学习中的多个方面，包括栈和队列、标准IO和文件IO、数组和链表、快速排序算法、后台程序执行、多线程和进程的比较、创建子进程中的写时拷贝...
IO进程.rar_IO进程基础课程_chairaj4
09-24
本课程“IO进程基础课程”由chairaj4提供，旨在为新手提供一个全面且深入的理解，帮助他们掌握IO操作的核心概念。 首先，我们需要了解什么是IO。在计算机系统中，IO是指计算机系统与外部设备之间进行数据传输的过程...
linux应用开发基础知识（三）——标准IO和文件IO、进程
C_glance的博客
04-08 1249
文件I/O：文件I/O称之为不带缓存的IO（unbuffered I/O)。不带缓存指的是每个read，write都调用内核中的一个系统调用。也就是一般所说的低级I/O——操作系统提供的基本IO服务，与os绑定，特定于linix或unix平台。标准I/O：标准I/O是ANSI C建立的一个标准I/O模型，是一个标准函数包和stdio.h头文件中的定义，具有一定的可移植性。标准I/O库处理很多细节。例如缓存分配，以优化长度执行I/O等。标准的I/O提供了三种类型的缓存。
精选资源
Linux 查看磁盘IO并找出占用IO读写很高的进程
01-09
`iotop -oP`会以人类可读的格式显示每个进程的读写总量、IO百分比以及进程对应的命令。通过这个信息，我们可以找到哪些进程正在大量消耗I/O资源。 - `pidstat`命令也可以提供类似的信息，尤其是`pidstat -d 1`可以每...
IO进程--标准IO
m0_49133235的博客
08-31 310
IO进程
【IO进程】进程
colorfulshark
03-29 1564
概念什么是进程？以及进程和程序的一个区别：程序： 把一个源代码文件经过编译器编译之后，生成一个文件，是可以执行的，这个可执行文件就是程序 text | data bss 代码段 数据段（data：全局或者静态（static）已经初始化的变量。bss： 全局或者静态未始化的变量 ）程序不执行，一直存放在磁盘或者硬盘，静态进程： 是描述程序的
IO进程(文件IO)
xcinop的博客
04-11 733
文件IO什么是文件IO11。
IO进程-进程/线程/进程间通信
zhong_hua210231的博客
02-20 894
初学者的笔记（IO进程）
IO进程的 初步学习
qq_62151962的博客
08-25 257
IO进程的初步了解
【Java】IO进程
colorfulshark
04-23 403
IO IO： 输入输出 — 写/读 文件 （1）java里IO操作最多的对象 （2）java.io.File类封装了文件对象 File类File对象代表一个路径下的文件或文件夹 File类创建 绝对路基 File f1 =new File("C:\qin.txt"); 相对路径 File f2 =new File("qin.txt"); 拼接路径 File f3 =new File("C
IO进程函数
MrWangHao的博客
04-29 146
1. 标准IO 1.1 fopen fclose errno strerror perror fgetc fopen：打开一个文件：FILE *fopen(const char *pathname, const char *mode)； mode:rr+ w w+ a a+ Eg：fp=fopen（"./test.txt","r...
进程中的IO
qq_42430426的博客
03-10 564
1.文件相关系统调用接口 1.1 标准库IO接口：fopen()/fwrite()/fread()/fseek()/flcose() （1）fopen 函数：FILE *fopen(char *filename,char *mode); 参数： filename：要打开的文件名称 mode：r：只读/r+：读写/w：只写会清空文件原有内容/w+：写+读，会清空文件原有内容/a：写在文件末尾/a+：...
IO进程——标准IO
ww1106的博客
08-30 197
通过fgetc fputc实现将一个文件的内容复制到另外一个文件中。创建一个usr.txt，其中第一行存储账户名，第二行存储密码。将1.txt的内容复制到2.txt中。提示：读取一次，输出一次。2. 判断与文件中存储的账户名，密码是否一致。3. 如果账户名不一致，则输出用户不存在。4. 如果密码不一致，则输出密码错误。1. 从终端获取一个用户名和密码。5. 如果均一致，则输出登录成功。...
【IO进程】进程间通信
colorfulshark
04-01 974
【1】进程间通信概述每一个进程虽然独立，但也需要让不同的进程实现数据的传输、还有信号通知通信方式： 传统的进程间通信： 无名管道、有名管道 --> 数据传输 信号 -》 异步通知系统5（System V）通信方式： 共享内存、消息队列 --》 数据传输 信号量集 --》 同步和
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值