【Linux进程通信 —— 管道】

已于 2024-05-15 21:33:50 修改
阅读量816 收藏 15
点赞数 26
分类专栏： Linux 文章标签： linux java 服务器
于 2024-05-15 21:32:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jokr_/article/details/138910751
版权

Linux进程通信 —— 管道

进程间通信介绍

进程间通信的概念

在 Linux 中，进程间通信（IPC，Inter-Process Communication）是指 不同进程之间交换数据和信息的一种机制。 这种通信可以是在同一台计算机上的不同进程之间，也可以是在不同计算机之间的进程之间。

进程间通信的目的

进程间通信（IPC） 的主要目的是实现不同进程之间的数据交换和协作，从而实现更复杂的任务和功能。以下是进程间通信的几个主要目的：

  1. 数据交换：进程间通信允许不同进程之间交换数据和信息。这些数据可以是简单的消息、文件、共享内存中的数据等。通过数据交换，不同进程可以共享信息，协作完成复杂的任务。

  2. 协作：进程间通信使得不同进程能够协同工作，共同完成某些任务。例如，一个进程负责生成数据，另一个进程负责处理数据，它们之间通过通信来协调工作。

  3. 资源共享：进程间通信可以实现共享资源，如共享内存、文件、设备等。多个进程可以同时访问和操作共享资源，从而提高系统的利用率和效率。

  4. 进程同步：进程间通信可以实现进程之间的同步操作，确保它们按照一定的顺序执行。例如，使用信号量来控制对共享资源的访问，或者使用消息队列来实现进程间的同步消息传递。

  5. 并发控制：进程间通信可以实现对并发访问的控制，避免竞态条件和数据不一致性。例如，通过信号量或互斥锁来控制对共享资源的访问，以确保数据的一致性和可靠性。

总的来说，进程间通信的目的是实现不同进程之间的数据交换、协作和同步，从而实现更复杂、更高效的系统功能和任务。它是操作系统中的重要概念，对于实现多任务处理、并发编程和分布式系统等方面具有重要意义。

进程间通信的本质

进程间通信的本质就是，让不同的进程看到同一份资源。

在一个正在运行的操作系统中，存在许多相互独立的进程，它们需要相互协作以确保操作系统的正常运行。为了实现这种协作，这些进程通过进程间通信来共享资源，即让不同的进程能够访问并操作同一份共享资源，从而实现数据共享和协作。
在这里插入图片描述

一个简单的例子是父子进程间的通信。假设父进程需要向子进程发送一个命令，子进程收到命令后执行相应的操作，并将结果返回给父进程。这里的通信可以通过管道、消息队列或共享内存来实现。父进程向管道写入命令，子进程从管道中读取命令并执行，然后将结果写回管道，父进程再从管道中读取结果。这样，父子进程之间就实现了简单的数据交换和通信。

进程间通信的分类

管道

  • 匿名管道pipe
  • 命名管道

System V IPC

  • System V消息队列
  • SystemV 共享内存
  • SystemV信号量

POSIXIPC

  • 消息队列
  • 共享内存
  • 信号量
  • 互斥量
  • 条件变量
  • 读写锁

管道

什么是管道

管道（Pipe） 是一种用于进程间通信的机制，允许一个进程的输出直接成为另一个进程的输入。它主要用于在父进程和子进程之间或者在同时运行的两个进程之间进行通信。管道可以分为匿名管道（Anonymous Pipe） 和 命名管道（Named Pipe） 两种类型。
在这里插入图片描述

匿名管道

匿名管道的原理

匿名管道用于进程间通信，且仅限于本地父子进程之间的通信。

匿名管道是一种单向通信管道，只能在相关的父子进程间使用。它是通过调用pipe()系统调用创建的，具有读端 和 写端 。匿名管道的数据流向是单向的，即数据只能从写端流入到读端。

在这里插入图片描述
注意：操作系统维护父子进程共享的文件资源时，并不会在父子进程间进行数据的写时拷贝。管道使用文件的概念，但操作系统并不会将进程通信的数据刷新到磁盘上，因为这样做既会涉及到IO操作从而降低效率，也是没有必要的。换言之，这些文件通常只存在于内存中，而不会被写入到磁盘上。

pipe

pipe函数是Unix/Linux操作系统提供的一个系统调用，用于创建一个匿名管道。它的原型如下：

#include <unistd.h>

int pipe(int pipefd[2]);

  • 参数pipefd是一个包含两个整数元素的数组，用于返回新创建的管道的文件描述符。pipefd[0]用于从管道中读取数据，pipefd[1]用于向管道中写入数据。

  • 调用 成功 时，返回值为 0 ；调用 失败 时，返回值为 -1 ，并设置全局变量errno来指示错误类型。

用fork来共享管道原理

在创建匿名管道实现父子进程间通信的过程中，需要pipe函数和fork函数搭配使用，具体步骤如下：

1、父进程调用pipe函数创建管道。
在这里插入图片描述
2、父进程创建子进程
在这里插入图片描述

3、父进程关闭写端，子进程关闭读端。

在这里插入图片描述

  1. 管道只能够进行单向通信，因此当父进程创建完子进程后，需要确认父子进程谁读谁写，然后关闭相应的读写端。
  2. 从管道写端写入的数据会被内核缓冲，直到从管道的读端被读取。
站在文件描述符角度-深度理解管道

在这里插入图片描述

站在内核角度-管道本质

在这里插入图片描述

管道读写规则

pipe2函数与pipe函数类似，同样用于创建一个匿名管道。它的原型如下：

#include <unistd.h>

int pipe2(int pipefd[2], int flags);

与 pipe 函数不同的是，pipe2 函数允许通过参数 flags 设置一些附加的选项，以控制管道的行为。常用的选项包括：

  • O_CLOEXEC：在父进程执行 fork 创建子进程时，子进程会自动关闭父进程中不需要的文件描述符。这可以通过设置 O_CLOEXEC 标志来实现，以确保在子进程中关闭管道的文件描述符。
  • O_NONBLOCK：设置管道的读取和写入操作为非阻塞模式。在非阻塞模式下，读取和写入操作会立即返回，不会等待直到管道中有数据可读或有空间可写。

这两个选项可以通过按位或运算组合使用。例如，要创建一个非阻塞的管道并在父进程中关闭不需要的文件描述符，可以将 flags 设置为 O_NONBLOCK | O_CLOEXEC。

pipe2 函数的返回值和 pipe 函数类似，成功时返回0，失败时返回-1，并设置全局变量 errno 来指示错误类型。

管道的特点

  • 单向性：管道是单向的，只能用于单向数据流的传输。通常有两种类型的管道：单向管道和双向管道。单向管道只能实现单向数据流的传输，而双向管道则可以实现双向数据流的传输。

  • 半双工：管道是半双工的，即同一时间只能有一个方向的数据流动。在一个管道中，数据只能单向流动，要么从父进程流向子进程，要么从子进程流向父进程。

  • 适用于有亲缘关系的进程：管道通常用于具有亲缘关系的进程之间进行通信，例如父子进程之间。因为管道是通过 fork 系统调用创建的，只有具有亲缘关系的进程才能共享同一个管道。

  • 有限缓冲区：管道具有有限的缓冲区，因此在读取端没有读取数据时，写入端会被阻塞。当管道的缓冲区已满时，写入端也会被阻塞，直到缓冲区有足够的空间来容纳写入的数据。

  • 不支持随机访问：管道是顺序访问的，不支持随机访问。也就是说，只能按照数据写入的顺序依次读取数据，不能直接定位到某个位置读取数据。

  • 自动关闭：在进程终止时，管道会自动关闭。当所有指向管道的文件描述符都被关闭时，管道将被系统自动释放。

管道的四种特殊情况

管道的四种特殊情况：

  1. 写端进程不写，读端进程一直读：

    • 情况描述：写端进程不向管道写入数据，但读端进程一直尝试读取数据。
    • 表现：读端进程会被挂起，直到管道中有数据可读。
    • 解释：读端进程在读取数据时，如果管道中没有数据可读，则会被挂起，直到有数据可供读取。

  2. 读端进程不读，写端进程一直写：

    • 情况描述：写端进程不断向管道写入数据，但读端进程没有读取数据。
    • 表现：当管道被写满后，写端进程会被挂起，直到管道中的数据被读取后才会继续写入。
    • 解释：当写端不断写入数据，而读端没有读取时，管道会被写满。此时写端进程会被挂起，直到读端读取数据释放空间。

  3. 写端进程写完后关闭写端：

    • 情况描述：写端进程将数据写入管道后关闭了写端。
    • 表现：读端进程将管道中的数据读完后，继续执行后续代码，而不会被挂起。
    • 解释：写端进程关闭写端后，读端进程读取完管道中的数据后会收到EOF，继续执行后续代码。

  4. 读端进程关闭读端：

    • 情况描述：读端进程关闭了读端，但写端进程仍在向管道写入数据。
    • 表现：操作系统会将写端进程杀掉。
    • 解释：当读端进程关闭读端后，写端继续向管道写入数据，此时操作系统会向写端进程发送信号，通知其管道已关闭，然后将写端进程杀掉。

示例：

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

int main() {
    int pipefd[2];
    pid_t pid;
    char buffer[10];

    // 创建管道
    if (pipe(pipefd) == -1) {
        perror("pipe");
        exit(EXIT_FAILURE);
    }

    // 创建子进程
    pid = fork();
    if (pid == -1) {
        perror("fork");
        exit(EXIT_FAILURE);
    }

    if (pid == 0) {  // 子进程
        // 关闭写端，子进程从管道中读取数据
        close(pipefd[1]);
        // 读取数据
        read(pipefd[0], buffer, sizeof(buffer));
        printf("Child Process: Data read from pipe: %s\n", buffer);
        // 关闭读端
        close(pipefd[0]);
        exit(EXIT_SUCCESS);
    } else {  // 父进程
        // 关闭读端，父进程向管道中写入数据
        close(pipefd[0]);
        // 写入数据
        write(pipefd[1], "Hello", 5);
        printf("Parent Process: Data written to pipe: Hello\n");
        // 关闭写端
        close(pipefd[1]);
        // 等待子进程结束
        wait(NULL);
        exit(EXIT_SUCCESS);
    }

    return 0;
}

在这个示例中，父进程创建了一个管道并生成了一个子进程。父进程通过管道将字符串"Hello"写入管道，而子进程则从管道中读取数据并打印到控制台上。在这个过程中，我们可以观察到以下特殊情况：

  • 写端进程不写，读端进程一直读：在这个示例中，如果父进程不写入数据，子进程会一直阻塞在读取管道的操作，直到有数据可读。
  • 读端进程不读，写端进程一直写：如果子进程不读取管道中的数据，而父进程持续写入数据，那么管道会被写满，父进程的写操作会阻塞，直到有空间可写。
  • 写端进程写完后关闭写端：在父进程写入数据后，关闭了写端。子进程读取完数据后，管道的读端会返回EOF，子进程继续执行后续代码。
  • 读端进程关闭读端：在子进程读取完数据后，关闭了读端。如果父进程继续写入数据，操作系统会向父进程发送信号，告知读端已关闭，然后父进程被杀死。
管道的大小

我们可以利用管道四种特殊情况中的第二种 读端进程不读，写端进程一直写 来验证：
让读端不读，写端进程一直写，直到写端被写满无法继续写时，则可以得到管道具体的大小。

#include <iostream>
#include <cerrno>
#include <cstring>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <string>

const int size = 1024;

//写
void SubProcessWrite(int wfd)
{
    int pipesize = 0;
    std::string message = "father, i am your son process!";
    while(true)
    {
        char c = 'A';
        write(wfd,&c,1);
        std::cout << "pipesize = " << ++pipesize << std::endl;
    }
}

//读
void FatherProcessRead(int rfd)
{
    // sleep(500);
    char inbuffer[size];    //用于储存读到的信息的缓冲区
    while(true)
    {
        // sleep(4);
        ssize_t n = read(rfd, inbuffer, sizeof(inbuffer) - 1);
        if(n > 0)
        {
            inbuffer[n] = 0;
            std::cout << "father get message"  << inbuffer << std::endl;
        }
    }
}

int main()
{
    //创建管道
    int pipefd[2];
    int n = pipe(pipefd);   //输出型参数

    if(n != 0)
    {
        std::cerr << "errno: " << errno << ":" << "errstring: " << strerror(errno) << std::endl;
        return 1;
    }

    //pipefd[0] ->0 -r 嘴巴 读   pipefd[1] ->1 -w 🖊 写
    std::cout << "pipefd[0]: " << pipefd[0] << " " << "pipefd[1]: "<< pipefd[1] << std::endl;

    //创建子进程
    pid_t id = fork();
    if(id == 0)
    {
        std::cout << "子进程已经关闭了读fd，保留写fd，准备开始写消息了。" << std::endl;
        //关闭不必要的fd
        //子进程
        //write
        close(pipefd[0]);

        SubProcessWrite(pipefd[1]);

        close(pipefd[1]);
        exit(0);
    }
  
    //父进程
    //read
    std::cout << "父进程已经关闭了写fd，保留读fd，准备开始读消息了。" << std::endl;
    close(pipefd[1]);
    
    // FatherProcessRead(pipefd[0]);
    // close(pipefd[0]);

    int status = 0;
    pid_t rid = waitpid(id,&status,0);
    if(rid > 0)
    {
        std::cout << "wait child process done, exit sig:" << (status&0x7f) << std::endl;
        std::cout << "wait chile process done, exit code(ign)" << ((status>>8)&0xff) << std::endl;
    }
    return 0;
}

在这里插入图片描述
可知：我当前Linux版本中管道的最大容量是65536字节。

命名管道

命名管道的原理

命名管道的原理

命名管道是一种特殊类型的文件系统对象，它允许不同进程通过文件来进行通信。其原理基于文件系统的特性，它实际上是一个由操作系统维护的特殊文件，具有磁盘上的路径名，可以在文件系统中找到。与匿名管道不同，命名管道可以通过文件系统中的路径名进行访问，从而允许不同进程在不同的时间段内进行通信。

创建一个命名管道

我们可以使用mkfifo命令创建一个命名管道。

qq@iZ0jl65jmm6w9evbwz2zuoZ:~/bt111/Linux/5_09/test$ mkfifo fifo

在这里插入图片描述
可以看到，创建出来的文件的类型是p，代表该文件是命名管道文件。
在这里插入图片描述
我们这里通过shell简单的进行两个进程的通信，这里可以看到左边的进程使用while done 来向fifo写入数据，右边进程来读取fifo的信息。

在这里插入图片描述

我们也可以使用mkfifo函数来创建命名管道

mkfifo函数
mkfifo函数是一个用于创建命名管道的Unix/Linux函数。他的原型如下：

#include <sys/types.h>
#include <sys/stat.h>

int mkfifo(const char *pathname, mode_t mode);

参数：

  • pathname：指定要创建的命名管道的路径名。
  • mode：指定创建的管道的权限模式（权限位）。三位八进制数字。具体的权限可查看这篇文章Linux当中的权限问题

  1. 创建命名管道： 首先，需要使用特定的系统调用（如mkfifo函数）在文件系统中创建一个命名管道。这个系统调用将在文件系统中创建一个特殊类型的文件，其类型为FIFO（先进先出），并分配一个唯一的路径名。

  2. 进程打开管道： 创建命名管道后，进程可以通过打开文件系统中的路径名来访问该管道。进程可以像打开普通文件一样打开命名管道，并且可以使用文件描述符来进行读取和写入操作。

  3. 进程读写管道： 一旦管道被打开，进程就可以使用相应的文件描述符进行读取和写入操作。写入到管道的数据会按照先进先出的顺序被读取出来。

  4. 进程关闭管道： 当进程不再需要使用管道时，应该关闭相应的文件描述符，以释放系统资源。

总的来说，命名管道的原理是利用文件系统的特性创建一个特殊类型的文件对象，允许不同进程通过文件进行通信。这种通信方式具有持久性和可靠性，不同进程可以在不同的时间段内进行通信，而不受进程生命周期的限制。

命名管道的打开规则
  • 如果当前打开操作是为读而打开FIFO时
    • O_NONBLOCK disable：阻塞直到有相应进程为写而打开该FIFO
    • O_NONBLOCK enable：立刻返回成功
  • 如果当前打开操作是为写而打开FIFO时
    • O_NONBLOCK disable：阻塞直到有相应进程为读而打开该FIFO
    • O_NONBLOCK enable：立刻返回失败，错误码为ENXIO
用命名管道实现 serve&client 通信

我们先来写一个管道文件，如何在serve 和 client 端分别打开这个管道文件。
在这个管道文件中分别封装 读操作接口 和 写操作接口 以供使用。

namePipe.hpp

#pragma once

#include <iostream>
#include <cstdio>
#include <cerrno>
#include <string>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

const std::string comm_path = "./myfifo";

#define DefaultFd -1
#define Creater 1
#define User 2
#define Read O_RDONLY
#define Write O_WRONLY
#define BassSize 4096

class NamePiped
{
private:
    bool OpenNamePipd(int mode)     //打开对应管道  mode决定打开方式
    {
        _fd = open(_fifo_path.c_str(),mode);
        if(_fd < 0)
        {
            return false;
        }
        return true;
    }

public:
    NamePiped(const std::string &path, int who)
        :_fifo_path(path)
        ,_id(who)
    {
        int res = mkfifo(_fifo_path.c_str(),0666);      //创建命名管道  名字是myfifo 
        if(res != 0)
        {
            //创建失败
            perror("mkfifo");
        }
        std::cout << "Creater create named pipe" << std::endl;
    }

    //创建打开接口
    //读
    bool OpenForRead()
    {
        return OpenNamePipd(Read);
    }
    //写
    bool OpenForWrite()
    {
        return OpenNamePipd(Write);
    }

    //write     输入项参数
    int WriteNamePipe(const std::string &in)
    {
        return write(_fd,in.c_str(),in.size());
    }
    //read      输出型参数
    int ReadNamePipe(std::string *out)
    {
        char buffer[BassSize];
        int n = read(_fd,buffer,sizeof(buffer));

        if(n > 0)
        {
            buffer[n] = 0;
            *out = buffer;
        }
        return n;
    }

    ~NamePiped()
    {
        if(_id == Creater)
        {
            int res = unlink(_fifo_path.c_str());
            if(res != 0)
            {
                perror("unlink");
            }
            std::cout << "creater free named pipe" << std::endl;
        }
        if(_fd != DefaultFd)    close(_fd);
    }
private:
    const std::string _fifo_path;   //命名管道的地址
    int _fd;    //fd  文件描述符
    int _id;    //id  用于判断Creater | User
};

client.cc

#include "namePipe.hpp"

//write 写
int main()
{
    NamePiped fifo(comm_path,User);

    if(fifo.OpenForWrite())
    {
        std::cout << "client open named pipe done" << std::endl;
        while(true)
        {
            std::cout << "Pleanse Enter>";
            std::string message;
            std::getline(std::cin,message);
            fifo.WriteNamePipe(message);
        }
    }
    return 0;
}

server.cc

#include "namePipe.hpp"

//read 读
int main()
{
    NamePiped fifo(comm_path,Creater);
    if(fifo.OpenForRead())
    {
        std::cout << "server open named pipe done" << std::endl;

        while(true)
        {
            std::string message;
            int n = fifo.ReadNamePipe(&message);

            if(n > 0)
            {
                std::cout << "Client say > " << message << std::endl;
            }
            else if(n == 0)
            {
                std::cout << "Client quit, Server Tool" << std::endl;
            }
            else
            {
                std::cout << "fifo.ReadNamedPipe Error" << std::endl;
                break;
            }
        }
    }
    return 0;
}

演示：

在这里插入图片描述

命名管道和匿名管道的区别
  • 匿名管道由pipe函数创建并打开。
  • 命名管道由mkfifo函数创建，由open函数打开。
  • FIFO（命名管道）与pipe（匿名管道）之间唯一的区别在于它们创建与打开的方式不同，一旦这些工作完成之后，它们具有相同的语义。
jokr_q
关注
专栏目录
进程管道
python编程
10-08 288
源码对管道的解释： The Pipe() function returns a pair of connection objects connected by a pipe which by default is duplex (two-way) 该函数返回一对连接用管道的默认两端的特征 Each connection object has ***send()*** and ***recv()*...
Linux进程通信——进程间的五种通信方式——管道、FIFO
最新发布
shion1114的博客
06-25 741
管道 (包括无名管道和命名管道) 、消息队列、信号量、共享存储、Socket、Streams。
Linux管道实现机制
12-16
Linux下的管道机制，实现进程间的通信，介绍了命名管道和匿名管道
[Perl]管道、进程及其他
phphot
09-21 2190
版权声明：可以任意转载，但转载时必须标明原作者charlee、原始链接http://tech.idv2.com/2008/09/04/perl-pipe-process-etc/以及本声明。昨天一个同事问我关于Perl中的 -| 描述符的问题。他的程序大概是这样的：unless (open FH, "-|") {  exec "foo bar";        # 用exec执行另一个程序  ex
Linux 进程、管道详解
一颗牙疼
12-17 247
gdb调试： 设置父进程调试路径：set follow-fork-mode parent (默认) 设置子进程调试路径：set follow-fork-mode child exec函数族： 使进程执行某一程序。成功无返回值，失败返回 -1 int execlp(const char *file, const char *arg, ...); 借助 PATH 环境变量找寻待执行程序 参...
进程通信－－进程管道
sever2012的专栏
12-26 1779
进程间通信的几种常用方式： 管道、命名管道、信号、信号量、共享内存、消息队列、套接字。 管道( pipe )：一种半双工的通信方式，数据只能单向流动且只能在具有共同祖先的进程间使用。 命名管道 (name pipe)：也是一种半双工的通信方式，但他允许不相关进程间的通信。 信号( sinal )：一个进程通过信号通知其他进程某事件已经发生，其他进程的反应如何及何时反应他都不管。 信号
实验一 进程通信——管道和信号实验报告.doc
05-13
本次实验是关于操作系统中的进程通信，主要涉及了进程的创建、控制、以及多种通信方式，包括信号通信和管道通信。通过实验，目的是加深对进程概念的理解，掌握并发执行的本质，并学习如何解决进程间的互斥问题。实验...
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的管道pipe实现原理
jinking01的专栏
09-30 1332
管道是进程间通信的主要手段之一。一个管道实际上就是个只存在于内存中的文件，对这个文件的操作要通过两个已经打开文件进行，它们分别代表管道的两端。 管道是一种特殊的文件，它不属于某一种文件系统，而是一种独立的文件系统，有其自己的数据结构。根据管道的适用范围将其分为：无名管道和命名管道。 无名管道 主要用于父进程与子进程之间，或者两个兄弟进程之间。在linux系统中可以通过系统调用建立起一个单向的通信管道，且这种关系只能由父进程来建立。 命名管道 ...
linux管道文件的实现原理,管道（无名管道）通信机制原理和实现详解
weixin_39986178的博客
05-08 847
管道(pipe)允许两个进程进行通信，是早期 UNIX 系统最早使用的一种IPC 机制。管道为进程之间的相互通信提供了一种较为简单的方法，尽管也有一定的局限性。在实现管道时，应该考虑以下四个问题：管道允许单向通信还是双向通信？如果允许双向通信，它是半双工的(数据在同一时间内只能按一个方向传输)还是全双工的(数据在同一时间内可在两个方向上传输)？通信进程之间是否应有一定的关系(如父子关系)？管道通信...
linux 进程管道
zhm4111的博客
08-21 439
进程访问机制，各个进程比较独立，不能访问对方的单元，但是进程不可能永远时对立的，必须涉及到信息的交互。 进程间通信传递两种信息，一种时标记、标志也就是状态（同步的状态信号量，异步的状态信号），另外一种是数据，即内容（传送的文件，磁盘、内存(有序的消息队列、共享内存，socket)、普通上锁文件、管道(有名管道、无名管道）、mmap。 管道的实现原理： 文件实现进程间的通信，普通文件可以同时被...
【linux】Linux管道的原理与使用场景
热门推荐
morris
12-26 4万+
总的来说，Linux管道是一个非常强大的工具，它可以帮助我们在处理数据时提供极大的灵活性。通过学习和掌握管道的使用，我们可以更有效地使用Linux命令行，更好地完成各种复杂的数据处理任务。
linux 管道的原理,（转）Linux下管道的原理
weixin_31742871的博客
05-13 882
7.1.1Linux管道的实现机制在Linux中，管道是一种使用非常频繁的通信机制。从本质上说，管道也是一种文件，但它又和一般的文件有所不同，管道可以克服使用文件进行通信的两个问题，具体表现为：·限制管道的大小。实际上，管道是一个固定大小的缓冲区。在Linux中，该缓冲区的大小为1页，即4K字节，使得它的大小不象文件那样不加检验地增长。使用单个固定缓冲区也会带来问题，比如在写管道时可...
深入理解Linux管道实现
wry2008wry的专栏
12-19 1623
曾经的一个误解： 日常工作中，要将数据从一个库迁移到另一个，可以使用“mysqldump xxx | mysql xxx”这个命令，这个命令先从源导出数据，然后经管道通过mysql命令导入目标数据库，正是通过这个命令的一些担心，加深了我对管道的认识。当时的担心是这样的：该命令不停的从源数据库取数据，然后写到目标数据库，那么在写入的时候，会不会创建多个MySQL链接，导致性能问题呢？查看后发现目标MySQL只有一个数据库连接，这是怎么回事呢？ 误解的澄清： 先放...
Linux进程间通信（IPC）机制之一：管道（Pipes）详解
B1ue还在专注
01-27 3025
对于Linux中最传统的进程通信方式—管道的知识点总结(ฅ´ω`ฅ)
Linux进程间通信（管道）
m0_49476241的博客
07-22 803
本篇文章将给大家讲解进程间通信中的管道使用方法和概念。本篇文章就讲解到这里，下篇文章讲解fifo有名管道。
Linux进程控制与无名管道通信详解
实验要求学生研究Linux系统进程通信的系统调用，这涉及到原码阅读和系统编程技巧。学生将学习如何利用无名管道（也称作匿名管道或FIFO）进行进程间的通信。无名管道允许不同进程共享内存区域，通过读写操作交换数据...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值