首页 > 系统相关 >进程间通讯

进程间通讯

时间：2023-02-19 23:00:52浏览次数：26  
标签：通讯 int ret 管道 进程 include buf

IPC：Inter Processes Communication

1 进程间通信的目的

  1. 数据传输
  2. 通知事件：一个进程需要向另一个或一组进程发送消息，通知它（它们）发生了某种事件（如进程终止时要通知父进程）。
  3. 资源共享：多个进程之间共享同样的资源。为了做到这一点，需要内核提供互斥和同步机制。
  4. 进程控制：有些进程希望完全控制另一个进程的执行（如Debug进程），此时控制进程希望能够拦截另一个进程的所有陷入和异常，并能够及时知道它的状态改变。

2 进程间通信的方式

image.png

3 管道的特点

  1. 管道其实是一个在内核内存中维护的缓冲器，这个缓冲器的存储能力是有限的，不同的操作系统大小不一定相同。
  2. 管道拥有文件的特质：读操作、写操作，匿名管道没有文件实体，有名管道有文件实体，但不存储数据。可以按照操作文件的方式对管道进行操作。
  3. 一个管道是一个字节流，使用管道时不存在消息或者消息边界的概念，从管道读取数据的进程可以读取任意大小的数据块，而不管写入进程写入管道的数据块的大小是多少。
  4. 通过管道传递的数据是顺序的，从管道中读取出来的字节的顺序和它们被写入管道的顺序是完全一样的。
  5. 在管道中的数据的传递方向是单向的，一端用于写入，一端用于读取，管道是半双工的。
  6. 从管道读数据是一次性操作，数据一旦被读走，它就从管道中被抛弃，释放空间以便写更多的数据，在管道中无法使用lseek()来随机的访问数据。

4 管道的数据结构

image.png

5 管道的工作图解

Tips:
注意创建匿名管道 int pipe(int pipefd[2]); 中参数的使用
0表示读，1表示写

image.png

6 匿名(无名)管道

6.1 概念

  1. 匿名管道只能在具有公共祖先的进程（父进程与子进程，或者两个兄弟进程，具有亲缘关系）之间使用。
  2. 匿名管道可以通信的原因在于:他们是共享文件描述符的.

统计一个目录中文件的数目命令：ls |wc–l，为了执行该命令，shell创建了两个进程来分别执行ls和wc。

image.png

6.2 案例

  1. man 2 pipe
  2. 一定要先有管道再去创建fork的子进程。否则的话，父子之间的文件就不共享了。
  3. 一个进程只负责写或者读行了。
  4. 为什么需要sleep？？？

因为两个进程谁先能抢到锁是不一定的，所以一个进程写完后睡一会让另外一个进程抢到锁进行读；否则会一直写

  1. 记得读完后清空

6.2.1 从管道中读与写

/*
    #include <unistd.h>
    int pipe(int pipefd[2]);
        功能：创建一个匿名管道，用来进程间通信。
        参数：int pipefd[2] 这个数组是一个传出参数。
            pipefd[0] 对应的是管道的读端
            pipefd[1] 对应的是管道的写端
        返回值：
            成功 0
            失败 -1

    管道默认是阻塞的：如果管道中没有数据，read阻塞，如果管道满了，write阻塞

*/

// 子进程发送数据给父进程，父进程读取到数据输出
#include <unistd.h>
#include <sys/types.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main() {

    // 在fork之前创建管道
    int pipefd[2];
    int ret = pipe(pipefd);
    if(ret == -1) {
        perror("pipe");
        exit(0);
    }

    // 创建子进程
    pid_t pid = fork();
    if(pid > 0) {
        // 父进程
        printf("i am parent process, pid : %d\n", getpid());

        // 关闭写端
        close(pipefd[1]);
        
        // 从管道的读取端读取数据
        char buf[1024] = {0};
        while(1) {
            int len = read(pipefd[0], buf, sizeof(buf));
            printf("parent recv : %s, pid : %d\n", buf, getpid());
            memset(buf, 0 , 1024);
        }

    } else if(pid == 0){
        // 子进程
        printf("i am child process, pid : %d\n", getpid());

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

        // 向管道中写入数据
        char buf[1024] = {0};
        while(1) {
            char * str = "hello,i am child";
            write(pipefd[1], str, strlen(str));
            //sleep(1);
        }
        
    }
    return 0;
}

6.2.2 实现父子进程间通信

/*
    实现 ps aux | grep xxx 父子进程间通信
    
    子进程： ps aux, 子进程结束后，将数据发送给父进程
    父进程：获取到数据，过滤
    pipe()
    execlp()
    子进程将标准输出 stdout_fileno 重定向到管道的写端。  dup2
*/

#include <unistd.h>
#include <sys/types.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <wait.h>

int main() {

    // 创建一个管道
    int fd[2];
    int ret = pipe(fd);

    if(ret == -1) {
        perror("pipe");
        exit(0);
    }

    // 创建子进程
    pid_t pid = fork();

    if(pid > 0) {
        // 父进程
        // 关闭写端
        close(fd[1]);
        // 从管道中读取
        char buf[1024] = {0};

        int len = -1;
        while((len = read(fd[0], buf, sizeof(buf) - 1)) > 0) {
            // 过滤数据输出
            printf("%s", buf);
            memset(buf, 0, 1024);
        }

        wait(NULL);

    } else if(pid == 0) {
        // 子进程
        // 关闭读端
        close(fd[0]);

        // 文件描述符的重定向 stdout_fileno -> fd[1]
        dup2(fd[1], STDOUT_FILENO);
        // 执行 ps aux
        execlp("ps", "ps", "aux", NULL);
        perror("execlp");
        exit(0);
    } else {
        perror("fork");
        exit(0);
    }

    return 0;
}

7 有名管道

7.1 概念

  1. 有名管道（FIFO）不同于匿名管道之处在于它提供了一个路径名与之关联，以FIFO的文件形式存在于文件系统中，并且其打开方式与打开一个普通文件是一样的，这样即使与FIFO的创建进程不存在亲缘关系的进程，只要可以访问该路径，就能够彼此通过FIFO相互通信，因此，通过FIFO不相关的进程也能交换数据。
  2. 一旦打开了FIFO，就能在它上面使用与操作匿名管道和其他文件的系统调用一样的I/O系统调用了（如read()、write()和close()）。与管道一样，FIFO也有一个写入端和读取端，并且从管道中读取数据的顺序与写入的顺序是一样的。FIFO的名称也由此而来：先入先出。对管道及FIFO的读总是从开始处返回数据，对它们的写则把数据添加到末尾。它们不支持诸如lseek()等文件定位操作。
  3. 有名管道（FIFO)和匿名管道（pipe）有一些特点是相同的，不一样的地方在于：
    1. FIFO 在文件系统中作为一个特殊文件存在，但 FIFO 中的内容却存放在内存中。
    2. 当使用 FIFO 的进程退出后，FIFO 文件将继续保存在文件系统中以便以后使用。
    3. FIFO 有名字，不相关的进程可以通过打开有名管道进行通信。

7.2 案例

有名管道的注意事项：
1.一个为只读而打开一个管道的进程会阻塞，直到另外一个进程为只写打开管道
2.一个为只写而打开一个管道的进程会阻塞，直到另外一个进程为只读打开管道

读管道：
    管道中有数据，read返回实际读到的字节数
    管道中无数据：
        管道写端被全部关闭，read返回0，（相当于读到文件末尾）
        写端没有全部被关闭，read阻塞等待

写管道：
    管道读端被全部关闭，进行异常终止（收到一个SIGPIPE信号）
    管道读端没有全部关闭：
        管道已经满了，write会阻塞
        管道没有满，write将数据写入，并返回实际写入的字节数。

7.2.1 新手练习

1 write.c

/*
    创建fifo文件
    1.通过命令： mkfifo 名字
    2.通过函数：int mkfifo(const char *pathname, mode_t mode);

    #include <sys/types.h>
    #include <sys/stat.h>
    int mkfifo(const char *pathname, mode_t mode);
        参数：
            - pathname: 管道名称的路径
            - mode: 文件的权限 和 open 的 mode 是一样的
                    是一个八进制的数
        返回值：成功返回0，失败返回-1，并设置错误号

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

int main() {

    // 1.判断文件是否存在
    int ret = access("test", F_OK);
    if(ret == -1) {
        printf("管道不存在，创建管道\n");
        
        // 2.创建管道文件
        ret = mkfifo("test", 0664);

        if(ret == -1) {
            perror("mkfifo");
            exit(0);
        }       

    }

    // 3.以只写的方式打开管道
    int fd = open("test", O_WRONLY);
    if(fd == -1) {
        perror("open");
        exit(0);
    }

    // 写数据
    for(int i = 0; i < 100; i++) {
        char buf[1024];
        sprintf(buf, "hello, %d\n", i);
        
        printf("write data : %s\n", buf);
        write(fd, buf, strlen(buf));
        sleep(1);
    }

    close(fd);

    return 0;
}

2 read.c

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

// 从管道中读取数据
int main() {

    // 1.打开管道文件
    int fd = open("test", O_RDONLY);
    if(fd == -1) {
        perror("open");
        exit(0);
    }

    // 读数据
    while(1) {
        char buf[1024] = {0};
        
        int len = read(fd, buf, sizeof(buf));
        if(len == 0) {
            printf("写端断开连接了...\n");
            break;
        }
        printf("recv buf : %s\n", buf);
    }

    close(fd);

    return 0;
}

7.2.2 防恋爱脑式聊天

只能回一句，必须等对方回了才行

1 chatA.c

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

int main() {

    // 1.判断有名管道文件是否存在
    int ret = access("fifo1", F_OK);
    if(ret == -1) {
        // 文件不存在
        printf("管道不存在，创建对应的有名管道\n");
        ret = mkfifo("fifo1", 0664);
        if(ret == -1) {
            perror("mkfifo");
            exit(0);
        }
    }

    ret = access("fifo2", F_OK);
    if(ret == -1) {
        // 文件不存在
        printf("管道不存在，创建对应的有名管道\n");
        ret = mkfifo("fifo2", 0664);
        if(ret == -1) {
            perror("mkfifo");
            exit(0);
        }
    }

    // 2.以只写的方式打开管道fifo1
    int fdw = open("fifo1", O_WRONLY);
    if(fdw == -1) {
        perror("open");
        exit(0);
    }
    printf("打开管道fifo1成功，等待写入...\n");
    // 3.以只读的方式打开管道fifo2
    int fdr = open("fifo2", O_RDONLY);
    if(fdr == -1) {
        perror("open");
        exit(0);
    }
    printf("打开管道fifo2成功，等待读取...\n");

    char buf[128];

    // 4.循环的写读数据
    while(1) {
        memset(buf, 0, 128);
        // 获取标准输入的数据
        fgets(buf, 128, stdin);
        // 写数据
        ret = write(fdw, buf, strlen(buf));
        if(ret == -1) {
            perror("write");
            exit(0);
        }

        // 5.读管道数据
        memset(buf, 0, 128);
        ret = read(fdr, buf, 128);
        if(ret <= 0) {
            perror("read");
            break;
        }
        printf("buf: %s\n", buf);
    }

    // 6.关闭文件描述符
    close(fdr);
    close(fdw);

    return 0;
}

2 chatB.c

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

int main() {

    // 1.判断有名管道文件是否存在
    int ret = access("fifo1", F_OK);
    if(ret == -1) {
        // 文件不存在
        printf("管道不存在，创建对应的有名管道\n");
        ret = mkfifo("fifo1", 0664);
        if(ret == -1) {
            perror("mkfifo");
            exit(0);
        }
    }

    ret = access("fifo2", F_OK);
    if(ret == -1) {
        // 文件不存在
        printf("管道不存在，创建对应的有名管道\n");
        ret = mkfifo("fifo2", 0664);
        if(ret == -1) {
            perror("mkfifo");
            exit(0);
        }
    }

    // 2.以只读的方式打开管道fifo1
    int fdr = open("fifo1", O_RDONLY);
    if(fdr == -1) {
        perror("open");
        exit(0);
    }
    printf("打开管道fifo1成功，等待读取...\n");
    // 3.以只写的方式打开管道fifo2
    int fdw = open("fifo2", O_WRONLY);
    if(fdw == -1) {
        perror("open");
        exit(0);
    }
    printf("打开管道fifo2成功，等待写入...\n");

    char buf[128];

    // 4.循环的读写数据
    while(1) {
        // 5.读管道数据
        memset(buf, 0, 128);
        ret = read(fdr, buf, 128);
        if(ret <= 0) {
            perror("read");
            break;
        }
        printf("buf: %s\n", buf);

        memset(buf, 0, 128);
        // 获取标准输入的数据
        fgets(buf, 128, stdin);
        // 写数据
        ret = write(fdw, buf, strlen(buf));
        if(ret == -1) {
            perror("write");
            exit(0);
        }
    }

    // 6.关闭文件描述符
    close(fdr);
    close(fdw);

    return 0;
}

标签：通讯,int,ret,管道,进程,include,buf
From： https://www.cnblogs.com/hereskiki/p/17135871.html

相关文章

  • 程序、进程和线程
    1、程序程序是指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念2、进程进程是执行程序的一次执行过程，他是一个动态的概念，是系统资源分配的单位3、线程......
  • 进程状态的切换
      当创建一个子进程后，该进程会进入就绪状态，再根据系统的调度，获得时间片，就进入运行状态，在运行状态的进程调用return等进程就结束了；如果在运行状态的进程调用read、write......
  • 守护进程、孤儿进程、僵尸进程
    守护进程：  孤儿进程：  僵尸进程： ......
  • 进程链进程扇
    进程链#include<stdio.h>#include<sys/types.h>#include<unistd.h>intmain(void){pid_tpid;inti;//printf("pid=%d\n",getpid());for(i......
  • 创建子进程拷贝的
      操作文件内核中的结构变化：  在创建一个子进程时，子进程也会有一个进程表项，子进程进程表项中的文件描述符表是复制的父进程的。......
  • Linux基础 - 进程管理 ps
     psaux|sort-k4,4nr|head-n10 #查看内存占用前10名的程序ps-e/ps-ef/ps-eF/ps-ely  #Toseeeveryprocessonthesystemusingstandardsy......
  • C#与西门子S7通讯
       https://blog.csdn.net/weixin_38950569/article/details/100167769  https://blog.csdn.net/qq_20792765/article/details/119032464 ......
  • python 进程与线程
    目录进程和线程概念Python中的多进程Python中的多线程多进程还是多线程单线程+异步I/O应用案例例子1：将耗时间的任务放到线程中以获得更好的用户体验。例子2：使用多进程对复......
  • Python多进程与多线程
    多进程更适合CPU密集型任务，而多线程更适合IO密集型任务。多进程multiprocessing模块importmultiprocessingdefmy_function(arg1,arg2):print("Dosomethingw......
  • linux 基础（10）进程管理
    使用ps观察程序ps-lps程序可以查询当前在运行的进程信息。ps-l可以列出详细的信息，默认仅列出当前bash相关的进程。sudo-ips-lFSUIDPIDPPIDCP......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99