Linux进程通信——管道

最新推荐文章于 2024-06-25 14:29:37 发布
最新推荐文章于 2024-06-25 14:29:37 发布
阅读量274 收藏
点赞数 1
分类专栏： 笔记 Linux 文章标签： linux unix 服务器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_63580639/article/details/129808438
版权
笔记 同时被 2 个专栏收录
78 篇文章 0 订阅
订阅专栏
Linux
19 篇文章 0 订阅
订阅专栏

管道

进程通信概念

什么是进程通信
首先我们清楚，进程是具有独立性的，如果想让进程通信，那么成本一定不低。

数据传输：一个进程需要将它的数据发送给另一个进程
资源共享：多个进程之间共享同样的资源。
通知事件：一个进程需要向另一个或一组进程发送消息，通知它（它们）发生了某种事件（如进程终止时要通知父进程）。
进程控制：有些进程希望完全控制另一个进程的执行（如Debug进程），此时控制进程希望能够拦截另一个进程的所有陷入和异常，并能够及时知道它的状态改变。

为什么要有进程通信
因为有时候我们是需要多进程协同去完成某种任务的。
怎么进行通信
目前通信有两套标准：

POSIX——让通信过程可以跨主机
System V——聚焦在本地通信（比较陈旧的标准）
重点：共享内存

管道

管道是Unix中最古老的进程间通信的形式。
我们把从一个进程连接到另一个进程的一个数据流称为一个“管道”。
管道是基于文件系统的。
那么两个进程通信：
第一个条件就是操作系统需要给双方进程提供内存空间。
第二个条件是要通信的进程看到同一份资源。（一般都是由操作系统直接或间接提供的）
不同的通信种类本质是：
上面所说的资源是操作系统的哪一个模块提供的。

匿名管道

父进程指向了一份文件，然后创建了子进程，子进程拷贝了父进程的代码和文件表，但是文件没被拷贝，这个时候父子进程看到的就是同一份文件，也就是同一份资源。
在这里插入图片描述
这一步才是通信的前提。
父进程往文件的缓冲区写数据，子进程从缓冲区读数据，这个就是进程之前的通信，这个方法及操作系统提供的内核文件，称为管道文件。（管道本质上就是文件）
那么需不需要将文件缓冲区的内容经过磁盘呢？之前说过打开一个文件是通过磁盘，但是因为磁盘是外设，效率很慢，所以我们实际上并不会这样。
就算不是在磁盘当中打开的文件，操作系统也能创建一个struct file对象，申请一个缓冲区。
所以这里说的管道其实是内存级文件，他不关心在磁盘的哪个路径下，要不要被写到磁盘，只要创建对象和缓冲区然后将地址添加到对应的文件描述符表就可以了。到时候操作系统会将这个文件变成管道文件。
那么我们如何让两个进程看到同一个管道文件呢？
首先清除fork是创建子进程的，子进程会继承父进程的文件地址，这样就能看到同一份管道文件了，但是这个文件并没有名字，所以叫做匿名管道。

创建匿名管道的过程

首先是父进程创建一个匿名管道。
在这里插入图片描述
分别以读和写的方式打开同一个文件。
然后是创建子进程，子进程会继承父进程对于这个文件的读写方式。
在这里插入图片描述
最后一部就是让父进程关闭读端，子进程关闭写端，这样就能让父进程给子进程读取数据了。
在这里插入图片描述
一般而言，我们管道只能用来单项数据通信。
管道就是输送资源的，就是数据。

这里我们来实现一下父子进程之间的通信：
这里说一下：CXX，CPP，CC都是C++源文件的后缀。
首先来了解一下创建管道的函数；
在这里插入图片描述
在这里插入图片描述
这个函数的参数是一个输出型参数，储存的是读端和写端，比如说文件描述符中，3和4是在读端和写端，那么就把3和4储存到这个数组当中。（pipefd[0]是读端，pipefd[1]是写端）这就相当于用读端和写端同时打开了一个文件。

#include <iostream>
#include <unistd.h>
#include <cassert>
#include <sys/types.h>
#include <sys/wait.h>
#include <cstring>
using namespace std;
int main()
{
    //第一步创建管道
    int fds[2];
    int n = pipe(fds);
    assert(n == 0);
    //第二部创建子进程
    pid_t id = fork();
    assert(id >= 0);
    if(id == 0)//子进程
    {
        close(fds[1]);//子进程关闭写入
        while(true)
        {
            char buffer[1024];
            ssize_t s = read(fds[0],buffer,sizeof(buffer)+1);//这里读取的内容永远少1是防止超过这个内容没有位置放\0
            if(s > 0) buffer[s] = 0;
            cout << buffer << " | my pid:" << getpid() << endl;
            //这里并没有休眠
        }
        close(fds[0]);
        exit(0);
    }
    close(fds[0]);//父进程关闭读取
    const char* s = "我是父进程，我在给你发消息";
    int cnt = 0;
    while(true)
    {
        cnt++;
        char buffer[1024];
        snprintf(buffer,sizeof buffer,"parent -> child say:%s[%d][%d]",s,cnt,getpid());
        write(fds[1],buffer,strlen(buffer));//这里传入的长度不用+1，因为系统不是通过\0来判定字符串结尾的
        sleep(1);//每隔1s写一次
    }
    close(fds[1]);
    n = waitpid(id,nullptr,0);
    assert(n == id);
    return 0;
}

在这里插入图片描述
在这里插入图片描述
通过这个可以发现父进程确实在给子进程发消息。
这种通信，称之为管道通信。
在这里插入图片描述
这个过程其实就相当于父进程通过操作系统写给管道，也就是相当于写给操作系统，然后子进程通过操作系统从管道当中读取内容。

管道读写的特性

读写特征：
1.上面的代码是隔着1s才会写入一次，如果改成sleep(5)就是5s写入一次。
这说明如果管道没有数据了，读端在读，默认会直接阻塞当前正在读取的进程，只有管道有数据，操作系统识别到，读端才会去读取数据。
2. 管道是一个固定大小的缓冲区。
如果将读端一直不读，写端一直写，那么缓冲区是会被写满的。

#include <iostream>
#include <unistd.h>
#include <cassert>
#include <sys/types.h>
#include <sys/wait.h>
#include <cstring>
using namespace std;
int main()
{
    //第一步创建管道
    int fds[2];
    int n = pipe(fds);
    assert(n == 0);
    //第二部创建子进程
    pid_t id = fork();
    assert(id >= 0);
    if(id == 0)//子进程
    {
        close(fds[1]);//子进程关闭写入
        while(true)
        {
            sleep(1000);
            char buffer[1024];
            ssize_t s = read(fds[0],buffer,sizeof(buffer)+1);//这里读取的内容永远少1是防止超过这个内容没有位置放\0
            if(s > 0) buffer[s] = 0;
            cout << buffer << " | my pid:" << getpid() << endl;
            
        }
        close(fds[0]);
        exit(0);
    }
    close(fds[0]);//父进程关闭读取
    const char* s = "我是父进程，我在给你发消息";
    int cnt = 0;
    while(true)
    {
        cnt++;
        char buffer[1024];
        snprintf(buffer,sizeof buffer,"parent -> child say:%s[%d][%d]",s,cnt,getpid());
        write(fds[1],buffer,strlen(buffer));//这里传入的长度不用+1，因为系统不是通过\0来判定字符串结尾的
        //sleep(1);//每隔1s写一次
        cout << "count:" << cnt << endl;
    }
    close(fds[1]);
    n = waitpid(id,nullptr,0);
    assert(n == id);
    return 0;
}

在这里插入图片描述
这里就是管道被写满了，如果再写就会把原来的数据覆盖。
写端写满的时候，写端会阻塞，等待读端读取。
如果写端一直写，读端一直读呢？

#include <iostream>
#include <unistd.h>
#include <cassert>
#include <sys/types.h>
#include <sys/wait.h>
#include <cstring>
using namespace std;
int main()
{
    //第一步创建管道
    int fds[2];
    int n = pipe(fds);
    assert(n == 0);
    //第二部创建子进程
    pid_t id = fork();
    assert(id >= 0);
    if(id == 0)//子进程
    {
        close(fds[1]);//子进程关闭写入
        while(true)
        {
            sleep(2);
            char buffer[1024];
            ssize_t s = read(fds[0],buffer,sizeof(buffer)+1);//这里读取的内容永远少1是防止超过这个内容没有位置放\0
            if(s > 0) buffer[s] = 0;
            cout << buffer << " | my pid:" << getpid() << endl;
            
        }
        close(fds[0]);
        exit(0);
    }
    close(fds[0]);//父进程关闭读取
    const char* s = "我是父进程，我在给你发消息";
    int cnt = 0;
    while(true)
    {
        cnt++;
        char buffer[1024];
        snprintf(buffer,sizeof buffer,"parent -> child say:%s[%d][%d]",s,cnt,getpid());
        write(fds[1],buffer,strlen(buffer));//这里传入的长度不用+1，因为系统不是通过\0来判定字符串结尾的
        //sleep(1);//每隔1s写一次
        cout << "count:" << cnt << endl;
    }
    close(fds[1]);
    n = waitpid(id,nullptr,0);
    assert(n == id);
    return 0;
}

在这里插入图片描述
管道是按照指定大小读取的，而不是一条一条读。
3.如果写端关闭，读端会发生什么呢？

#include <iostream>
#include <unistd.h>
#include <cassert>
#include <sys/types.h>
#include <sys/wait.h>
#include <cstring>
using namespace std;
int main()
{
    //第一步创建管道
    int fds[2];
    int n = pipe(fds);
    assert(n == 0);
    //第二部创建子进程
    pid_t id = fork();
    assert(id >= 0);
    if(id == 0)//子进程
    {
        close(fds[1]);//子进程关闭写入
        while(true)
        {
            //sleep(2);
            char buffer[1024];
            ssize_t s = read(fds[0],buffer,sizeof(buffer)+1);//这里读取的内容永远少1是防止超过这个内容没有位置放\0
            if(s > 0) 
            {
                buffer[s] = 0;
                cout << buffer << " | my pid:" << getpid() << endl;
            }
            else if(s == 0)
            {
                cout << "end" << endl;
                break;
            }
        }
        close(fds[0]);
        exit(0);
    }
    close(fds[0]);//父进程关闭读取
    const char* s = "我是父进程，我在给你发消息";
    int cnt = 0;
    while(true)
    {
        cnt++;
        char buffer[1024];
        snprintf(buffer,sizeof buffer,"parent -> child say:%s[%d][%d]",s,cnt,getpid());
        write(fds[1],buffer,strlen(buffer));//这里传入的长度不用+1，因为系统不是通过\0来判定字符串结尾的
        //sleep(1);//每隔1s写一次
        break;
    }
    close(fds[1]);
    n = waitpid(id,nullptr,0);
    assert(n == id);
    return 0;
}

在这里插入图片描述
写端关闭，读端返回0。
4.读关闭会发生什么呢？
操作系统当然会自己判断，如果都不读了，就没必要去写了，会发送给进程一个信号，终止写端。
这里操作系统会发送13信号。
在这里插入图片描述

管道本身的特征

1.管道的生命周期是进程的生命周期
2.管道可以用来进行具有血缘关系的进程之间进行通信，常用于父子通信。
3.管道是面向字节流的（网络）
4.半双工——单向通信（别名）
5.互斥同步机制——对共享资源进行保护的方案。（读写的特性）

在平时使用 | 这种的，比如：
sleep 10000 | sleep 200
这就是匿名管道，操作系统会创建父子进程，然后通过管道连接起来，其实命令行解释器就是会去寻找 | 然后进行一系列操作。

基于管道的进程池设计

思路：
在这里插入图片描述
这是用一个进程去控制多个进程，这个进程收到某个指令，然后发给这些进程的其中之一，假如说要发1就是帮忙打印东西，2就是帮忙计算等等功能（具体功能不重要，这里不实现），发的是几，功能就是对应的。
这里要注意，不能总让一个子进程工作，要分工做。

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

#define PROCSS_NUM 5//创建子进程的数量
#define MakeSeed() srand((unsigned long)time(nullptr)^getpid()^rand()%1234)//生成伪随机数

typedef void(*func_t)();//重命名函数指针，其实就是命名为func_t

//处理条件
void downLoadTask()
{
    cout << getpid() << ":下载任务" << endl;
    sleep(1);
}
void ioTask()
{
    cout << getpid() << ":IO任务" << endl;
    sleep(1);
}
void flushTask()
{
    cout << getpid() << ":刷新任务" << endl;
    sleep(1);
}
void loadTaskFunc(vector<func_t>& func_t)
{
    func_t.push_back(downLoadTask);
    func_t.push_back(ioTask);
    func_t.push_back(flushTask);
}

class subEd//子进程的信息
{
public:
    subEd(pid_t id,int fd)
        :_subId(id)
        ,_writeFd(fd)
    {
        char nameBuffer[1024];
        snprintf(nameBuffer,sizeof nameBuffer,"process-%d[pid(%d)-fd(%d)]",num++,_subId,_writeFd);//进程的名字是进程编号+pid+写端口
        _name = nameBuffer;
    }
public:
    static int num;//进程的编号
    string _name;//进程名字
    pid_t _subId;//进程pid
    int _writeFd;//进程写端
};

int subEd::num = 0;

int recvTask(int readFd)
{
    int code = 0;
    ssize_t s = read(readFd,&code,sizeof(int));
    if(s==4) return code;
    else return -1;
}
void createSubProcess(vector<subEd>&arr,vector<func_t>&funcMap)
{
    for(int i = 0;i < PROCSS_NUM; i++)
    {
        int fds[2];
        int n = pipe(fds);
        assert(n==0);
        (void)n;//这里防止Release之后上面的assert直接被忽略，导致n被判断没被使用
        pid_t id = fork();
        if(id == 0)
        {
            //子进程处理任务
            close(fds[1]);//关闭写端
            while(1)
            {
                //获取命令码，如果没发送，子进程阻塞
                int commandCode = recvTask(fds[0]);//读取父进程发来的信息
                //完成任务
                if(commandCode >= 0 && commandCode < funcMap.size()) funcMap[commandCode]();//调用处理条件的信息表
                else break;//如果没有可读取的内容就跳出循环，就等于写端关闭，读端也关闭
            }
            exit(0);
        }
        close(fds[0]);//父进程关闭读端
        subEd sub(id,fds[1]);//创建子进程id和父进程写fd储存的对象，这里要注意，走到这里的是父进程，父进程拿到的返回值是子进程的pid
        arr.push_back(sub);//放入子进程信息的数组中
    }
}
void sendTask(subEd& s,int taskIdx)
{
    cout << "send task num:" << taskIdx << "send to ->" << s._name << endl;
    int n = write(s._writeFd,&taskIdx,sizeof(taskIdx));//这里为了安全必须发送的是四个字节
    assert(n == sizeof(int));
    (void)n;
}
void loadBlanceContrl(vector<subEd>&arr,vector<func_t>&funcMap,int count)
{
    int processsum = arr.size();//一共多少个子进程
    int tasksum = funcMap.size();//一共多少种方案
    int flag = 0;
    if(count > 0) flag = count;
    while(1)
    {
        //随机选择一个子进程
        int idx = rand() % processsum;
        //选择一个任务
        int taskIdx = rand() % tasksum; 
        //任务发送给选择的进程
        sendTask(arr[idx], taskIdx);
        sleep(1);
        if(flag)
        {
            count--;
            if(count == 0) break;
        }
    }
    //这里关闭父进程的写端
    for(int i = 0; i < processsum; i++) close(arr[i]._writeFd);
}
void waitProcess(vector<subEd>&arr)
{
    for(int i = 0; i < arr.size();i++)
    {
        waitpid(arr[i]._subId,nullptr,0);
        cout << "wait sub process success ...:" << arr[i]._subId << endl;
    }
}
int main()
{
    MakeSeed();//随机数的开始
    //创建子进程和父进程之前的通信
    vector<func_t>funcMap;//储存子进程处理的条件
    vector<subEd>arr;//储存子进程的pid和要处理的信息
    loadTaskFunc(funcMap);
    createSubProcess(arr,funcMap);
    //父进程
    int taskcnt = 5;//假设等于0就是永远进行
    loadBlanceContrl(arr,funcMap,taskcnt);
    //回收子进程
    waitProcess(arr);
    return 0;
}

在这里插入图片描述
在创建子进程那部分有一个雷点，就是创建第一个子进程的时候，父进程的fd有两个是指向管道的，子进程就继承了父进程的文件描述符表，然后进程读写关闭。
创建第二个子进程的时候，第二个子进程也继承了父进程的文件描述符表，同样是关闭对应的读写端，但是父进程的文件描述符表中还存着对于第一个子进程的写端，这就是一个隐藏的bug。
也就是说我们进行关闭父进程的第一个写端的时候，其实还有其他进程指向第一个子进程，也就是说他的返回值不是0，并且依旧阻塞。
在这里插入图片描述
如果是批量化的关闭所有的写段文件描述符，前面的子进程没有关闭完成写端就先不关闭进程，就要去后面的子进程，到了最后一个进程，只有一个父进程对应的写段，那么关闭之后最后一个子进程就没有对应的写段了，相对应的文件描述符表也就关闭了，这个时候倒数第二个进程也没有指向它的写段，也可以关闭了，以此类推。这也是解决问题的一个办法。
还有一种方法是这样的：

void createSubProcess(vector<subEd>&arr,vector<func_t>&funcMap)
{
    vector<int> deletefd;//储存父进程写段的fd
    for(int i = 0;i < PROCSS_NUM; i++)
    {
        int fds[2];
        int n = pipe(fds);
        assert(n==0);
        (void)n;//这里防止Release之后上面的assert直接被忽略，导致n被判断没被使用
        pid_t id = fork();
        if(id == 0)
        {
            for(int i = 0; i < deletefd.size();i++) close(deletefd[i]);//在子进程中关闭掉对应的写端
            //子进程处理任务
            close(fds[1]);//关闭写端
            while(1)
            {
                //获取命令码，如果没发送，子进程阻塞
                int commandCode = recvTask(fds[0]);//读取父进程发来的信息
                //完成任务
                if(commandCode >= 0 && commandCode < funcMap.size()) funcMap[commandCode]();//调用处理条件的信息表
                else break;//如果没有可读取的内容就跳出循环，就等于写端关闭，读端也关闭
            }
            exit(0);
        }
        close(fds[0]);//父进程关闭读端
        subEd sub(id,fds[1]);//创建子进程id和父进程写fd储存的对象，这里要注意，走到这里的是父进程，父进程拿到的返回值是子进程的pid
        arr.push_back(sub);//放入子进程信息的数组中
        deletefd.push_back(fds[1]);//将父进程写端放入
    }
}

在这里插入图片描述
这样运行起来也是没有任何问题的。

命名管道

这个管道可用于两个没有血缘关系的进程进行通信。
在这里插入图片描述
第一个参数是文件路径+文件名，第二个参数是权限（和创建文件的权限是一个东西）。
成功返回0，失败返回-1.
在这里插入图片描述
这个就是命名管道，P开头。
在这里插入图片描述
注意：这里大小都没变。
在这里插入图片描述
本来应该打印在左侧的通过管道文件传到了右边。此时这里就完成了命令行式的打印。
在这里插入图片描述
但是这里还是大小不变。这是为什么呢？
首先来看看这行图：
在这里插入图片描述
两个进程对应的两个文件描述符的表指向了同一个文件，但是内存中的文件其实也是操作系统通过数据结构搞出来的结构体，这里struct file并不需要两个，只需要一个就够了。
那么我们这里看到的同一份资源就是file了，所以就不需要在刷新到缓冲区了然后到磁盘里面了，就相当于是一个内存级的文件。

让两个无血缘关系的进程通信

首先让两个进程打开指定名称（路径+文件名）的同一个文件。（路径+文件名）唯一性
头文件——comm.hpp
两个源文件——client.cc server.cc
其实这里就等于两个进程间的对于一个文件进行操作。
在这里插入图片描述
然后来看一下删除文件的操作，参数是文件目录+名，返回值是0成功，-1失败。
comm.hpp

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

#define NAME_PIPE "/home/mfc/exercise/name_pipe/my_pipe"

bool createFifo(const string& path)
{
    umask(0);
    int n = mkfifo(NAME_PIPE,0600);
    if(n == 0) return 1;
    else 
    {
        cout << "errror:" << errno << "err string:" << strerror(errno) << endl;
        return 0;
    }
}

void removeFifo(const string& path)
{
    int n = unlink(path.c_str());
    assert(n==0);
    (void)n;
}

client.cc

#include"comm.hpp"
int main()
{
    int wfd = open(NAME_PIPE,O_WRONLY);//打开同一个文件
    if(wfd < 0) exit(1);

    char buffer[1024];
    while(1)
    {
        cout << "Please Say:";
        fgets(buffer,sizeof(buffer),stdin);
        ssize_t n = write(wfd,buffer,strlen(buffer));
        assert(n == strlen(buffer));
        (void)n;
    }

    close(wfd);
    return 0;
}

server.cc

#include"comm.hpp"
int main()
{
    int n = createFifo(NAME_PIPE);//创建管道文件
    assert(n);
    (void)n;
    int rfd = open(NAME_PIPE,O_RDONLY);//打开同一个文件
    if(rfd < 0) exit(1);
    char buffer[1024];
    while(1)
    {
        ssize_t s = read(rfd,buffer,sizeof(buffer)-1);//-1是防止没位置放\0
        if(s > 0)
        {
            buffer[s]=0;
            cout << "client-<server:"<< buffer;
        }
        else if(s == 0)//写入关闭
        {
            cout << "client quit, me too!" <<endl;
            break;
        }
        else//失败
        {
            cout << "err string:" << strerror(errno) << endl;
            break;
        }
    }

    close(rfd);
    removeFifo(NAME_PIPE);//删除管道文件
    return 0;
}

在这里插入图片描述
这样两个没有血缘关系的进程就通信成功了。
那么这里还有两个小细节：
第一个
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
读端这一步为什么不跑了呢？因为在open这里阻塞中。需要写端打开才能继续跑。
在这里插入图片描述
管道文件必须两端同时打开才会继续运行代码。
第二个
我们读端输出并没有换行，为什么自己换行了呢？因为我们平时输入之后会按回车，其实就等于\n 了，打印的时候也算上了\n，所以打印出来的结果就是带换行的。
这里也可以这么写：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

ℳℓ白ℳℓ夜ℳℓ
关注
专栏目录
Linux 管道通信
阿修罗道
09-09 6955
一、定义   管道是单向的、先进先出的。它将一个程序的输入和另一个程序的输出连接起来。数据被一个进程读出后，将被从管道中删除。分为无名和有名管道两种。前者用于父进程和子进程间的通信，后者用于同一系统的两个进程间通信。   二、无名管道      int  pi
Linux 进程间通信（管道）
最新发布
2201_75663820的博客
09-22 1230
进程间通信、匿名管道、命名管道 ...
Linux管道通信
ZR
06-11 473
无名管道和有名管道 先说一下有名管道和无名管道用的函数： 无名管道使用的是 pipe() 有名管道使用的是fifo() 无名管道主要用于有血缘关系的两个进程间通信，是内核使用环形队列机制实现，借助内核缓冲区实现的。有名管道主要用于两个不相干的进程间通信，我认为之所以叫有名管道是因为他们借助mkfifo（）函数创建的伪文件利用内核缓冲区进行通信，因为创建文件可以指定文件名所以操作和使用文件几乎一样。 首先关于无名管道 pipe()函数 需要指定两个文件描述符，通过pipe()函数创建一个管道使其一端读文件一端
实验一 进程通信——管道和信号实验报告.doc
05-13
本次实验是关于操作系统中的进程通信，主要涉及了进程的创建、控制、以及多种通信方式，包括信号通信和管道通信。通过实验，目的是加深对进程概念的理解，掌握并发执行的本质，并学习如何解决进程间的互斥问题。实验...
Linux进程通信——进程间的五种通信方式——管道、FIFO
shion1114的博客
06-25 740
管道 (包括无名管道和命名管道) 、消息队列、信号量、共享存储、Socket、Streams。
Linux——进程间通信——管道（文件）通信
x20020402的博客
11-01 941
（1）管道（2）信号量（3）共享内存（4）消息队列（5）套接字。
实验四：Linux下进程管道通信.docx
04-13
**实验四：Linux下进程管道通信** 实验的目标是理解和掌握Linux操作系统中进程间通信的管道机制，通过系统调用pipe()实现数据交换。管道是一种特殊类型的文件，它允许相关进程之间进行单向通信。在这个实验中，我们...
Linux进程间通信——管道通信详解
Serendipity_00的博客
11-26 5732
进程间通信：管道引言进程间通信管道 引言 进程是相互独立的，每个进程都有自己的虚拟地址空间，虚拟地址空间通过页表的映射，映射到自己的物理内存上，互不影响。正因为如此，进程间通信就变得很麻烦，操作系统为了使进程间能够通信，会提供一个介质，让多个进程都能够访问，也就是在内存上开辟一块公共资源，让进程在公共资源上交流。 进程间通信 在Linux系统中，有时候需要多个进程之间相互协作，共同完成某项任务，进程之间或线程之间有时候需要传递信息，有时候需要同步协调彼此工作，则就会出现进程间通信。 信号也是进程间通信的一种
Linux-管道通信
bananawolf的博客
04-28 1000
管道通信的原理，匿名管道和命名管道的使用，以及区别
Linux系统中的管道通信
weixin_44212838的博客
11-06 1831
管道，是Linux下常用的进程间通信手段，具体的通信方法是 父进程打开管道文件，被子进程继承，通过文件描述符fd，并且，数据在管道文件中的读写是彻底的内存级别的，即不与磁盘交互，读和写皆是在内存中，效率也有一定的保证。以上三点机制，使得管道能像文件一样操作的同时，避同时免了使用普通文件进程间通信的 极度的 不安全性。需要注意的是，文件名只是用来标识唯一性，数据的传输更匿名管道一样，完全是内存级的。2.往管道中写入数据时，如果管道满了，或正在被读取，执行写入的进程会阻塞等待。
Linux通信之管道通信
qq_41033011的博客
07-24 280
IPC方法(InterProcess Communication) Linux环境下，进程地址空间相互独立，每个进程各自有不同的用户地址空间。任何一个进程的全局变量在另一个进程中都看不到，所以进程和进程之间不能相互访问，要交换数据必须通过内核，在内核中开辟一块缓冲区，进程1把数据从用户空间拷到内核缓冲区，进程2再从内核缓冲区中把数据读走，内核提供的这种机制称为进程间通信 在进程间完成数据传递需要借助os提供的特殊方法，如：文件、管道、信号、共享内存、消息队列、套接字、命名管道等。 现如今常用的
Linux进程控制与无名管道通信详解
实验要求学生研究Linux系统进程通信的系统调用，这涉及到原码阅读和系统编程技巧。学生将学习如何利用无名管道（也称作匿名管道或FIFO）进行进程间的通信。无名管道允许不同进程共享内存区域，通过读写操作交换数据...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

ℳℓ白ℳℓ夜ℳℓ

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值