进程间通信--管道

最新推荐文章于 2022-10-06 19:54:23 发布
最新推荐文章于 2022-10-06 19:54:23 发布
阅读量144 收藏 1
点赞数
分类专栏： Linux 文章标签： 进程通信 管道
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sinat_36629696/article/details/79827797
版权
匿名管道

匿名管道只能使有亲缘关系的进程通信

01.利用匿名管道从键盘获取数据显示到屏幕

//匿名管道

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

//创建一个匿名管道 fd:文件描述符数组  fd[0]:读端  fd[1]:写端
//成功返回 0 , 失败返回错误代码
int pipe(int fd[2]);

//创建一个匿名管道, 从键盘写入数据到管道, 从管道读取数据, 显示到屏幕
int main()
{
    int fds[2];
    char buf[1024];
    int len = 0;

    if(pipe(fds) != 0)
    {
        perror("pipe");
        return -1;
    }

    //从键盘读数据
    //char *fgets(char *buf, int bufsize, FILE *stream);
    //参数
    //*buf: 字符型指针，指向用来存储所得数据的地址。
    //bufsize: 整型数据，指明存储数据的大小。
    //*stream: 文件结构体指针，将要读取的文件流。
    while(fgets(buf, 1024, stdin) != NULL)
    {
        len = strlen(buf);
        //数据写入管道
        //ssize_t write(int fd, const void *buf, size_t nbyte);
        //fd：文件描述符；
        //buf：指定的缓冲区，即指针，指向一段内存单元；
        //nbyte：要写入文件指定的字节数；
        //返回值：写入文档的字节数（成功）；-1（出错）
        if(write(fds[1], buf, len) < 0)
        {
            perror("write");
            break;
        }
        //清空buf
        //void *memset(void *s, int ch, size_t n);
        //函数解释：将s中当前位置后面的n个字节 （typedef unsigned int size_t ）用 ch 替换并返回 s 。
        //memset：作用是在一段内存块中填充某个给定的值，它是对较大的结构体或数组进行清零操作的一种最快方法
        memset(buf, 0x00, sizeof(buf));

        //从管道读取数据
        //函数名: read
        //功 能: 从文件中读
        //用 法: int read(int handle, void *buf, int nbyte);
        if(read(fds[0], buf, 1024) < 0)
        {
            perror("read");
            return -1;
        }

        len = strlen(buf);

        //写到屏幕上
        if(write(1, buf, len) < 0)
        {
            perror("write");
            return -1;
        }
    }
}
02.利用匿名管道实现父子进程间的通信

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

//父子进程通过匿名管道进行通信

//错误处理
#define ERR_EXIT(m)     \ 
do                      \ 
{                       \ 
    perror(m);          \
    exit(EXIT_FAILURE); \
}while(0);

int main(int agrc, char argv[])
{
    int fds[2];
    //创建匿名管道
    if(pipe(fds) != 0)
    {
        ERR_EXIT("pipe error");
        return -1;
    }

    //创建子进程
    pid_t pid = fork();
    if(pid == -1)
    {
        ERR_EXIT("fork error");
        return -1;
    }

    //子进程
    if(pid == 0)
    {
        //关闭子进程的读端
        close(fds[0]);
        //往写端写入hello
        if(write(fds[1], "hello", 5) == -1)
        {
            ERR_EXIT("write error");
            return -1;
        }
        close(fds[1]);
    }

    //父进程
    //关闭父进程的写端
    close(fds[1]);
    char buf[10] = {0};
    //从读端读入到buf
    if(read(fds[0], buf, 5) > 0)
    {
        printf("buf = %s\n", buf);
    }
    return 0;
}
命名管道

如果想实现在两个毫不相干的进程间通信,就可以使用命名管道

01.使用命名管道实现文件赋值

src.h


//命名管道, 可用于不相关的进程间通信
//表头文件
#include<sys/types.h>
#include<sys/stat.h>
#include<unistd.h>
#include<errno.h>
#include<stdlib.h>
#include<stdio.h>
#include<fcntl.h>
//定义函数
//int mkfifo(const char* pathname,mode_t mode);
//若成功则返回0，否则返回-1，错误原因存于errno中

#define ERR_EXIT(m)     \                                                                                                
do                      \
{                       \
    perror(m);          \
    exit(EXIT_FAILURE); \
}while(0);


//用命名管道实现文件拷贝
//把数据从abc文件写入管道

int main()
{
    //创建一个名为 tmp 的命名管道, 权限664
    mkfifo("tmp", 0664);
    //以只读方式打开 abc 文件
    int in_fd = open("abc", O_RDONLY);
    if(in_fd == -1)
    {
        ERR_EXIT("open error");
    }

    //以读写方式打开 tmp 管道文件
    int out_fd = open("tmp", O_WRONLY);
    if(out_fd == -1)
    {
        ERR_EXIT("open error");
    }

    char buf[1024] = {0};
    int len = 0;

    //从in_fd读数据到buf
    if((len = read(in_fd, buf, 1024)) > 0)
    {
        //从buf写数据到out_fd
        write(out_fd, buf, len);
    }

    close(in_fd);
    close(out_fd);

    return 0;
}

dst.h


//命名管道, 可用于不相关的进程间通信
//表头文件
#include<sys/types.h>
#include<sys/stat.h>
#include<unistd.h>
#include<errno.h>
#include<stdlib.h>
#include<stdio.h>
#include<fcntl.h>
//定义函数
//int mkfifo(const char* pathname,mode_t mode);
//若成功则返回0，否则返回-1，错误原因存于errno中

#define ERR_EXIT(m)     \                                                                                                
do                      \
{                       \
    perror(m);          \
    exit(EXIT_FAILURE); \
}while(0);


//用命名管道实现文件拷贝
//把数据从tmp文件写入abc_cp

int main()
{
    int out_fd = open("abc_cp", O_WRONLY | O_CREAT | O_TRUNC, 0664);
    if(out_fd == -1)
    {
        ERR_EXIT("open error");
    }

    int in_fd = open("tmp", O_RDONLY);
    if(in_fd == -1)
    {
        ERR_EXIT("open error");
    }

    char buf[1024] = {0};
    int len = 0;

    if((len = read(in_fd, buf, 1024)) > 0)
    {
        //从buf写数据到out_fd
        write(out_fd, buf, len);
    }

    close(in_fd);
    close(out_fd);
    unlink("tmp");
    return 0;
}

这里写图片描述
这里写图片描述

02.利用命名管道进行server和client之间的对话

server.c


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

//利用命名管道实现server和client的对话

#define ERR_EXIT(m) \
    do{\
    perror(m);\
    exit(EXIT_FAILURE);\
    }while(0);

int main()
{
    umask(0);
    //创建 tmp 管道, 权限664
    if ( mkfifo("tmp", 0664) < 0 )
    {
        ERR_EXIT("mkfifo error");
    }

    //只读打开 tmp 管道文件
    int rfd = open("tmp", O_RDONLY);
    if(rfd == -1)
    {
        ERR_EXIT("opne error");
    }

    char buf[1024] = {0};
    while(1)
    {
        buf[0] = 0;
        printf("Please Wait ... \n");

        size_t s = read(rfd, buf, sizeof(buf)-1);
        if(s > 0)
        {
            buf[s-1] = 0;
            printf("client say: %s\n", buf);
        }
        if(s == 0)
        {
            printf("client quit, me too \n");
            exit(EXIT_SUCCESS);
        }
        if(s < 0)
        {
            ERR_EXIT("read error");
        }
    }

    close(rfd);
    return 0;
}

client.c


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

//利用命名管道实现server和client的对话

#define ERR_EXIT(m) \
    do{\
    perror(m);\
    exit(EXIT_FAILURE);\
    }while(0);

int main()
{
    //读写打开 tmp 管道文件
    int wfd = open("tmp", O_WRONLY);
    if(wfd < 0)
    {
        ERR_EXIT("opne error");
    }

    char buf[1024] = {0};
    while(1)
    {
        buf[0] = 0;
        printf("I say: ");
        fflush(stdout);

        size_t s = read(0, buf, sizeof(buf)-1);
        if(s > 0)
        {
            buf[s] = 0;
            write(wfd, buf, sizeof(buf)-1);
        }
        if(s <= 0)
        {
            ERR_EXIT("read error");
        }
    }

    close(wfd);
    return 0;
}

这里写图片描述
这里写图片描述

  • 管道提供流式服务
  • 一般而言，进程退出，管道释放，所以管道的生命周期随进程
  • 内核会对管道操作进行同步与互斥
  • 管道是半双工的，数据只能向一个方向流动；需要双方互相通信时，需要建立起两个管道
rugu-sco
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
操作系统实验题目之进程间通信(含c语言代码)
qq_41620273的博客
12-25 1494
编写server和client两个程序，利用命名管道实现两个进程间的消息互通。 解答： 源代码 Server.c: Client.c 运行截图 使用多线程和信号量解决生产者/消费者问题：有一个长度为N的缓冲池被生产者和消费者共同使用。只要缓冲池未满，生产者就可以将消息送入缓冲池；只要缓冲池不空，消费者便可从缓冲池中取走一个消息。生产者向缓冲池放入消息的同时，消费者不能操作缓冲池，反之亦然。 解答： 源代码 #include <pthread.h> #include <std.
【Linux】七、进程间通信
枫叶先生的博客
03-29 845
进程间通信介绍|匿名管道|命名管道详解
用命名管道实现server和client之间的通信
qq_39014877的博客
03-02 1663
匿名管道只能用于具有亲缘关系的进程之间进行通信，通常，一个管道由一个进程创建，然后该进程调用fork，此后父子进程之间就可以用管道通信了。 如果我们想在不相关的进程之间交换数据，可以使用FIFO文件来做这项工作，它经常被称为命名管道。命名管道是一种特殊类型的文件(管道类型)。 1、Makefile .PHONY:all all:client server client:client.c gcc...
Linux命名管道实现进程间的通信sever/client
h593245631的博客
05-23 1008
1.命名管道 管道应用的一个限制就是只能在具有共同祖先（具有亲缘关系）的进程间通信。 如果我们想在不相关的进程之间交换数据，可以使用FIFO文件来做这项工作，它经常被称为命名管道 命名管道是一种特殊类型的文件 2.匿名管道与命名管道的区别 匿名管道由pipe函数创建并打开。 命名管道由mkfifo函数创建，打开用open FIFO（命名管道）与pipe（匿名管道）之间唯一的区别在它们创...
【Linux】使用命名管道实现server&client通信
qq_42270373的博客
01-11 2038
什么是命名管道 匿名管道应用的一个限制就是只能在具有亲缘关系的进程之间进行通信，如果我们想在没有关系的两个进程之间进行通信，可以使用fifo来实现，这种实现方式被称为命名管道。命名管道是一种特殊类型的文件。 创建一个命名管道 1.命名管道可以从命令行上创建： $ mkfifo filename 2.命名管道也可以使用代码创建，相关函数有： int mkfifo(cons...
进程间通信—管道
weixin_54131692的博客
10-06 123
进程间通信—管道
进程间通信-管道
04-29
总结起来，命名管道是进程间通信的一种有效手段，尤其适用于同一系统内的进程通信。通过`mkfifo()`、`open()`、`write()`和`read()`等系统调用，我们可以构建起可靠的通信链路。`PipeC.cpp`和`PipeS.cpp`的代码示例...
linux系统编程--进程间通信--管道
08-21
Linux系统编程--进程间通信--管道 在Linux系统中，进程间通信是指不同的进程之间交换数据和信息的方式。由于进程之间的地址空间相对独立，不能像线程之间通过全局变量通信，因此需要其他机制来实现进程间通信。 ...
操作系统实验五-进程间通信-管道通信
12-06
操作系统实验五 进程间通信——管道通信 无名管道 有名管道 write()和read() pipe() 函数int pipe(int fd[2])创建一个管道 lockf()函数使用管道通信时，可关闭某些不需要的读或写描述符wait()、waitpid()，sys/wait....
进程的管道通信编制一段程序，实现进程的管道通信，使用系统调用pipe（）建立一个管道文件；两个子进程P1和P2
03-13
进程的管道通信 编制一段程序，实现进程的管道通信，使用系统调用pipe（）建立一个管道文件；两个子进程P1和P2 分别向管道各写一句话： Child1 is sending a message！ Child2 is sending a message！ 而父进程则从管道中读出来自于两个子进程的信息，显示在屏幕上。要求父进程先接收子进程P1发来的 消息，然后再接收子进程P2发来的消息。
利用共享内存及管道实现进程间通信
03-26
利用共享内存及管道实现进程间通信，内附 server 及 client 两个通信进程源码，经测试可用。可供需要者参考，开发工具：VC++6.0。
Linux的进程间通信-管道.doc
最新发布
04-30
Linux的进程间通信-管道.doc
进程间通信-邮槽
04-29
进程间通信（IPC，Inter-Process Communication）是操作系统中一种重要的技术，允许不同的进程之间共享数据和信息。在Windows操作系统中，提供了多种实现IPC的方法，其中包括邮槽（Mailslot）。邮槽是一种简单且高效...
C#进程间通信-管道代码实例
12-04
本文将深入探讨C#中的管道进程间通信，并通过一个具体的代码实例进行解析。 首先，管道通信是一种半双工（即数据只能单向流动）的数据通信方式，可以用于同一台机器上的不同进程之间，甚至在不同的网络节点之间。C#...
NamedPipe，利用命名管道实现进程间通信
Hisin Wang的专栏
04-18 8777
管道是一种用于在进程间共享数据的机制,其实质是一段共享内存. Windows系统为这段共享的内存设计采用数据流I/0的方式来访问. 命令管道可以在任意进程间通信,通信是双向的,任意一端都可读可写,但是在同一时间只能有一端读,一端写.Note:须包含头文件 #include <windows.h>一、服务端// 1.1创建命名管道 #define BUFSIZE 4096 LPCTSTR lpsz
C# 使用管道Pipe在进程间通信
03-25
进程间通信的一种方式，Pipes：管道，分为无名管道：在父子进程间交换数据；有名管道：可在不同主机间交换数据，分为服务器方和客户方，在Win9X下只支持有名管道客户。 1、进程间通信 2、管道Pipe通信

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值