Linux进程间通信（IPC）机制之一：管道（Pipes）详解

本文介绍: 对于Linux中最传统的进程通信方式—管道的知识点总结(ฅ´ω`ฅ)

0:50━━━━━━️💟──────── 2:43
🔄 ◀️ ⏸ ▶️ ☰

💗关注👍点赞🙌收藏您的每一次鼓励都是对我莫大的支持😍

#include <unistd.h>
功能:创建一无名管道
原型
int pipe(int fd[2]);
参数
fd：文件描述符数组,其中fd[0]表示读端, fd[1]表示写端
返回值:成功返回0，失败返回错误代码

#include <iostream>
#include <cassert>
#include <cstring>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <cstdio>
#include <cstdlib>

#define MAX 1024

using namespace std;

int main()
{
    // 第1步，建立管道
    int pipefd[2]={0};
    int n=pipe(pipefd);
    assert(n==0);
    (void)n; // 防止编译器告警，意料之中，用assert，意料之外，用if

    // 第2步，创建子进程
    pid_t id=fork();
    if(id<0)
    {
        perror("fork");
        return 1;
    }
    // 子写，父读
    // 第3步，父子关闭不需要的fd，形成单向通信的管道
    if (id == 0)
    {
        //子关读
        close(pipefd[0]);
        int cnt = 0;
        while(true)
            {
                //利用write写
                char message[MAX];
                snprintf(message, sizeof(message), "hello father, I am child, pid: %d, cnt: %d", getpid(), cnt);
                cnt++;
                write(pipefd[1], message, strlen(message));
                sleep(1);
            }

        cout << "child close w piont" << endl;
        exit(0);
    }

    // 父进程，关闭写
    close(pipefd[1]);
    char buffer[MAX];
    while(true)
        {
            // sleep(2000);
            ssize_t n = read(pipefd[0], buffer, sizeof(buffer)-1);
            if(n > 0)
            {
                buffer[n] = 0; // '', 当做字符串
                cout << getpid() << ", " << "child say: " << buffer << " to me!" << endl;
            }
            else if(n == 0)
            {
                cout << "child quit, me too !" << endl;
                break;
            }
            cout << "father return val(n): " << n << endl;
            sleep(1);

        }
    cout << "read point close"<< endl;
    close(pipefd[0]);

    return 0;
}

// a. 管道的4种情况
//    1. 正常情况，如果管道没有数据了，读端必须等待，直到有数据为止(写端写入数据了)
//    2. 正常情况，如果管道被写满了，写端必须等待，直到有空间为止(读端读走数据)
//    3. 写端关闭，读端一直读取, 读端会读到read返回值为0， 表示读到文件结尾
//    4. 读端关闭，写端一直写入，OS会直接杀掉写端进程，通过想目标进程发送SIGPIPE(13)信号，终止目标进程 
// b. 管道的5种特性
//    1. 匿名管道,可以允许具有血缘关系的进程之间进行进程间通信，常用与父子,仅限于此
//    2. 匿名管道，默认给读写端要提供同步机制 --- 了解现象就行
//    3. 面向字节流的 --- 了解现象就行
//    4. 管道的生命周期是随进程的
//    5. 管道是单向通信的，半双工通信的一种特殊情况

#include <sys/types.h>
#include <sys/stat.h>
int mkfifo(const char *pathname, mode_t mode);

#include <iostream>
#include <cstring>
#include <cerrno>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#define FILENAME "fifo"

bool MakeFifo()
{
    int n = mkfifo(FILENAME, 0666);
    if(n < 0)
    {
        std::cerr << "errno: " << errno << ", errstring: " << strerror(errno) << std::endl;
        return false;
    }

    std::cout << "mkfifo success... read" << std::endl;
    return true;
}

int main()
{
Start:
    int rfd = open(FILENAME, O_RDONLY);
    if(rfd < 0)
    {
        std::cerr << "errno: " << errno << ", errstring: " << strerror(errno) << std::endl;
        if(MakeFifo()) goto Start;
        else return 1;
    }
    std::cout << "open fifo success..." << std::endl;

    char buffer[1024];
    while(true)
    {
        ssize_t s = read(rfd, buffer, sizeof(buffer)-1);
        if(s > 0)
        {
            buffer[s] = 0;
            std::cout << "Client say# " << buffer << std::endl;
        }
        else if(s == 0)
        {
            std::cout << "client quit, server quit too!" << std::endl;
            break;
        }
    }

    close(rfd);
    std::cout << "close fifo success..." << std::endl;

    return 0;
}

#include <iostream>
#include <cstring>
#include <cerrno>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#define FILENAME "fifo"

int main()
{
    int wfd = open(FILENAME, O_WRONLY);
    if (wfd < 0)
    {
        std::cerr << "errno: " << errno << ", errstring: " << strerror(errno) << std::endl;
        return 1;
    }
    std::cout << "open fifo success... write" << std::endl;

    std::string message;
    while (true)
    {
        std::cout << "Please Enter# ";
        std::getline(std::cin, message);

        ssize_t s = write(wfd, message.c_str(), message.size());
        if (s < 0)
        {
            std::cerr << "errno: " << errno << ", errstring: " << strerror(errno) << std::endl;
            break;
        }
    }

    close(wfd);
    std::cout << "close fifo success..." << std::endl;

    return 0;
}

.PHONY:all
all:server client

server:server.cc
	g++ -o $@ $^ -std=c++11
client:client.cc
	g++ -o $@ $^ -std=c++11
.PHONY:clean
clean:
	rm -f server client fifo