linux篇【9】：进程间通信——＜前序＞

目录

一.通信背景

3.进程间通信目的

4.进程间通信发展

5.进程间通信分类

二.管道——匿名管道

1.匿名管道原理 

2.匿名管道特点

3.打开进程读写的系统接口：pipe

4.管道的代码-演示pipe通信的基本过程-匿名管道

5.实现业务处理的管道代码-父进程控制子进程

6.进程池应用-多进程业务

 进程池应用代码：

7.匿名管道特征总结:

三.管道——命名管道

1.命名管道原理

2.mkfifo 创建命名管道

3.命名管道应用代码：

makefile

comm.h

clientFifo.cpp

serverFifo.cpp

---

一.通信背景

1.进程是具有独立性的!——导致进程间想交互数据，成本会非常高
进程为什么要通信：需要多进程进行协同处理一件事情
2.不要以为，进程独立了，就是彻底独立，有时候，我们需要双方能够进行一定程度的信息交互

3.进程间通信目的

数据传输：一个进程需要将它的数据发送给另一个进程

资源共享：多个进程之间共享同样的资源。

通知事件：一个进程需要向另一个或一组进程发送消息，通知它（它们）发生了某种事件（如进程终止时要通知父进程）。

进程控制：有些进程希望完全控制另一个进程的执行（如Debug进程），此时控制进程希望能够拦截另一个进程的所有陷入和异常，并能够及时知道它的状态改变

4.进程间通信发展

管道

System V进程间通信

POSIX进程间通信

5.进程间通信分类

典型进程间通信方式： 管道，共享内存，消息队列，信号量，网络通信，文件 等多种方式

管道

        匿名管道pipe

        命名管道

System V IPC

        System V 消息队列

        System V 共享内存

        System V 信号量

POSIX IPC

        消息队列

        共享内存

        信号量

        互斥量

        条件变量

        读写锁

二.管道——匿名管道

因为进程有独立性。
所以通信之前，我们需要让不同的进程看到同一份资源(文件，内存块..)
我们要学的进程间通信，不是告诉我们如何通信。而是解决：他们两个如何先看到同一份资源!
资源的不同决定了不同种类的通信方式!

第一种通信方式—>管道（提供共享资源的一种手段）

1.匿名管道原理 

父进程写入文件的缓冲区，子进程去缓冲区里读，就实现了两个进程看到同一份资源，这个用于通信的内存级文件就叫做管道（普通级文件是为了保存数据到磁盘的）。struct file中有inode，inode中有一个联合体可以来表示自己是管道/块设备/文件/字符

2.匿名管道特点

都是单向的!
管道传输资源的——这个资源就是 数据
进程间通信管道——>单向的，传输数据的!

进程间通信管道是单向的过程图：

①为什么父进程要分别打开读和写? ——答：为了让子进程继承，让子进程不用再打开了!（如果父进程只是打开写，子进程也会继承写，那就没人读了，让子进程读的话还得再打开读）
②为什么父子要关闭对应的读写?——答：管道必须是单向通信的。父进程关闭读，子进程关闭写，就构成单向的父写子读了。
③谁决定，父子关闭什么读写? ——答：不是由管道本身决定的， 是由你的需求决定的!

一个进程一旦退出了，进程中打开的所有描述符都会关闭，释放资源。只要不是循环，理论上打开的文件描述符不close也可以，因为进程退出会自动关闭文件描述符，但是尽量保持良好代码规范，不用了就释放。
举个例子，拆房，拆房的时候不要的家具不需要额外拉出来拆，因为房子一旦拆了所有的东西会一并当作垃圾回收，但是如果没拆房之前有家具不用了就要赶紧拉出去扔了，要不然家里就摆满了

3.打开进程读写的系统接口：pipe

man 2 pipe  ：pipe底层封装open，open了两次，第一次O_RDONLY，第二次O_WRONLY，把读写描述符分别放在数组pipefd[0]，pipefd[1]。 返回值 ——> 成功返回0，失败返回-1

4.管道的代码-演示pipe通信的基本过程-匿名管道

①当父进程没有写入数据的时候，子进程在等。所以，父进程写入之后，子进程才能read(会返回)到数据，子进程打印读取数据要以父进程的节奏为主!
②父进程和子进程读写管道的时候(是有一定的顺序性的！)。那么父子进程各自printf的时候，会有顺序吗?——答：无序。printf就是向显示器写入，也是文件，但是缺乏访问控制。
③父进程和子进程读写管道的时候：
——管道内部，没有数据，reader就必须阻塞等待(read)，等管道有数据（阻塞等待就是当前进程的 task_ struct 放入等待队列中，R->S/D/T）
——管道内部，如果数据被写满，writer就必须阻塞等待(write)等待管道中有空间
因为pipe内部自带访问控制机制——同步和互斥机制

#include <cstdio>
#include <cstring>
#include <ctime>
#include <sys/wait.h>
#include <sys/types.h>
#include <unistd.h>
//演示pipe通信的基本过程 -- 匿名管道
int main()
{
    // 1. 创建管道
    int pipefd[2] = {0};
    if(pipe(pipefd) != 0)
    {
        cerr << "pipe error" << endl;
        return 1;
    }
    // 2. 创建子进程
    pid_t id = fork();
    if(id < 0)
    {
        cerr << "fork error" << endl;
        return 2;
    }
    else if (id == 0)
    {
        // child
        // 子进程来进行读取, 子进程就应该关掉写端
        close(pipefd[1]);
        #define NUM 1024
        char buffer[NUM];
        while(true)
        {
            cout << "时间戳: " << (uint64_t)time(nullptr) << endl;
            // 子进程没有带sleep，为什么子进程你也会休眠呢？？
            memset(buffer, 0, sizeof(buffer));
            sleep(100);
            ssize_t s = read(pipefd[0], buffer, sizeof(buffer) - 1);
            if(s > 0)
            {
                //读取成功
                buffer[s] = '\0';
                cout << "子进程收到消息,内容是: " << buffer << endl;
            }
            else if(s == 0) //当read返回0时说明写端已关闭，所以要退出
            {
                cout << "父进程写完了，我也退出啦" << endl;
                break;
            }
            else{
                //Do Nothing
            }
        }
        close(pipefd[0]);
        exit(0);
    }
    else
    {
        // parent
        // 父进程来进行写入，就应该关掉读端
        close(pipefd[0]);
        const char *msg = "你好子进程，我是父进程, 这次发送的信息编号是: ";
        int cnt = 0;
        // while(cnt < 5)
        while(1)
        {
            char sendBuffer[1024];
            sprintf(sendBuffer, "%s : %d", msg, cnt);
            //sleep(30); // 这里是为了一会看现象明显
            write(pipefd[1], sendBuffer, strlen(sendBuffer)); //要不要+1 1,0
            cnt++;
            cout << "cnt: " << cnt << endl;
        }
        close(pipefd[1]);
        cout << "父进程写完了" << endl;
    }
    pid_t res = waitpid(id, nullptr, 0);
    if(res > 0)
    {
        cout << "等待子进程成功" << endl;
    }
    // 0 -> 嘴巴 -> 读（读书）
    // 1 -> 笔 -> 写的
    // cout << "fd[0]: " << pipefd[0] << endl;
    // cout << "fd[1]: " << pipefd[1] << endl;
    return 0;
}

5.实现业务处理的管道代码-父进程控制子进程

assert处只是换了一种写法，原写法是：

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

using namespace std;

typedef void (*functor)();

vector<functor> functors; // 方法集合
// for debug
unordered_map<uint32_t, string> info;

void f1()
{
    cout << "这是一个处理日志的任务, 执行的进程 ID [" << getpid() << "]"
         << "执行时间是[" << time(nullptr) << "]\n" << endl;
    //
}
void f2()
{
    cout << "这是一个备份数据任务, 执行的进程 ID [" << getpid() << "]"
         << "执行时间是[" << time(nullptr) << "]\n" << endl;
}
void f3()
{
    cout << "这是一个处理网络连接的任务, 执行的进程 ID [" << getpid() << "]"
         << "执行时间是[" << time(nullptr) << "]\n" << endl;
}

void loadFunctor()
{
    info.insert({functors.size(), "处理日志的任务"});
    functors.push_back(f1);

    info.insert({functors.size(), "备份数据任务"});
    functors.push_back(f2);

    info.insert({functors.size(), "处理网络连接的任务"});
    functors.push_back(f3);
}


2. 父进程控制子进程
int main()
{
    // 0. 加载任务列表
    loadFunctor();

    // 1. 创建管道
    int pipefd[2] = {0};
    if (pipe(pipefd) != 0)
    {
        cerr << "pipe error" << endl;
        return 1;
    }

    // 2. 创建子进程
    pid_t id = fork();
    if (id < 0)
    {
        cerr << " fork error " << endl;
        return 2;
    }
    else if (id == 0)
    {
        // 3. 关闭不需要的文件fd
        // child,read
        close(pipefd[1]);
        // 4. 业务处理
        while (true)
        {
            uint32_t operatorType = 0;
            // 如果有数据，就读取，如果没有数据，就阻塞等待, 等待任务的到来
            ssize_t s = read(pipefd[0], &operatorType, sizeof(uint32_t));
            if (s == 0)
            {
                cout << "我要退出啦,我是给人打工的,老板都走了...." << endl;
                break;
            }
            //这里if(s == sizeof(uint32_t));换一种断言的写法
            assert(s == sizeof(uint32_t));
            // debug 模式下：assert断言，是有效的
            // release 模式：断言就没有了
            // 一旦断言没有了，s变量就是：只被定义但没有被使用。
            //release模式下只定义不使用，可能会有warning
            (void)s;    //保证s变量被使用过

            if (operatorType < functors.size())
            {
                functors[operatorType]();
            }
            else
            {
                cerr << "bug? operatorType = " << operatorType << std::endl;
            }
        }
        close(pipefd[0]);
        exit(0);
    }
    else
    {
        srand((long long)time(nullptr));
        // parent,write - 操作
        // 3. 关闭不需要的文件fd
        close(pipefd[0]);
        // 4. 指派任务
        int num = functors.size();
        int cnt = 10;
        while (cnt--)
        {
            // 5. 形成任务码
            uint32_t commandCode = rand() % num;
            std::cout << "父进程指派任务完成，任务是: " << info[commandCode] << " 任务的编号是: " << cnt << std::endl;
            // 向指定的进程下达执行任务的操作
            write(pipefd[1], &commandCode, sizeof(uint32_t));
            sleep(1);
        }
        close(pipefd[1]);
        pid_t res = waitpid(id, nullptr, 0);
        if (res)
            cout << "wait success" << endl;
    }
    return 0;
}

6.进程池应用-多进程业务

 进程池应用代码：

 注意：关闭写段在这里统一在最后回收资源时关闭。
   

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

using namespace std;

typedef void (*functor)();

vector<functor> functors; // 方法集合
// for debug
unordered_map<uint32_t, string> info;

void f1()
{
    cout << "这是一个处理日志的任务, 执行的进程 ID [" << getpid() << "]"
         << "执行时间是[" << time(nullptr) << "]\n" << endl;
    //
}
void f2()
{
    cout << "这是一个备份数据任务, 执行的进程 ID [" << getpid() << "]"
         << "执行时间是[" << time(nullptr) << "]\n" << endl;
}
void f3()
{
    cout << "这是一个处理网络连接的任务, 执行的进程 ID [" << getpid() << "]"
         << "执行时间是[" << time(nullptr) << "]\n" << endl;
}

void loadFunctor()
{
    info.insert({functors.size(), "处理日志的任务"});
    functors.push_back(f1);

    info.insert({functors.size(), "备份数据任务"});
    functors.push_back(f2);

    info.insert({functors.size(), "处理网络连接的任务"});
    functors.push_back(f3);
}

// int32_t: 进程pid, int32_t: 该进程对应的管道写端fd
typedef std::pair<int32_t, int32_t> elem;
int processNum = 5;

void work(int blockFd)
{
    cout << "进程[" << getpid() << "]" << " 开始工作" << endl;
    // 子进程核心工作的代码
    while (true)
    {
        // a.阻塞等待  b. 获取任务信息
        uint32_t operatorCode = 0;
        ssize_t s = read(blockFd, &operatorCode, sizeof(uint32_t));
        if(s == 0) break;
        assert(s == sizeof(uint32_t));
        (void)s;

        // c. 处理任务
        if(operatorCode < functors.size()) functors[operatorCode]();
    }
    cout << "进程[" << getpid() << "]" << " 结束工作" << endl;
}

// [子进程的pid, 子进程的管道fd]
void blanceSendTask(const vector<elem> &processFds)
{
    srand((long long)time(nullptr));
    while(true)
    {
        sleep(1);
        // 选择一个进程, 选择进程是随机的，没有压着一个进程给任务
        // 较为均匀的将任务给所有的子进程 --- 负载均衡
        uint32_t pick = rand() % processFds.size();

        // 选择一个任务
        uint32_t task = rand() % functors.size();

        // 把任务给一个指定的进程
        write(processFds[pick].second, &task, sizeof(task));

        // 打印对应的提示信息
        cout << "父进程指派任务->" << info[task] << "给进程: " << processFds[pick].first << " 编号: " << pick << endl;
    }
}

int main()
{
    loadFunctor();
    vector<elem> assignMap;
    // 创建processNum个进程
    for (int i = 0; i < processNum; i++)
    {
        // 定义保存管道fd的对象
        int pipefd[2] = {0};
        // 创建管道
        pipe(pipefd);
        // 创建子进程
        pid_t id = fork();
        if (id == 0)
        {
            // 子进程读取, r -> pipefd[0]
            close(pipefd[1]);
            // 子进程执行
            work(pipefd[0]);
            close(pipefd[0]);
            exit(0);
        }
        //父进程做的事情, pipefd[1]
        close(pipefd[0]);
        elem e(id, pipefd[1]);
        assignMap.push_back(e);
    }
    cout << "create all process success!" << std::endl;
    // 父进程, 派发任务
    blanceSendTask(assignMap);

    // 回收资源
    for (int i = 0; i < processNum; i++)
    {
        if (waitpid(assignMap[i].first, nullptr, 0) > 0)
            cout << "wait for: pid=" << assignMap[i].first << " wait success!"
                 << "number: " << i << "\n";
        close(assignMap[i].second);    注意！！关闭写段在这里统一关闭
    }
}

7.匿名管道特征总结:

（命令行管道|，其实就是匿名管道）
（1）管道只能用来进行具有血缘关系的进程之间，进行进程间通信。常用于父子通信
（2）管道只能单向通信(内核实现决定的)，半双工的一 种特殊情况（半双工：某时某刻只要一个人在说一个人在听）
（3）管道自带同步机制(pipe满—> writer等 ;  pipe空—>  reader等) --自带访问控制
（4）管道是面向字节流的----现在还解释不清楚--先写的字符，一定是先被读取的，没有格式边界，需要用户来定义区分内容的边界
[sizeof (uint32_ t)] ---- 网络tcp,我们自定义协议的
（5）管道的生命周期--管道是文件--进程退出了，曾经打开的文件会怎么办?退出--管道的生命周期随进程。与该文件相关的所有进程退出，此文件的引用计数--到0，文件也会关闭。

三.管道——命名管道

只能父子(血缘)通信? ?毫不相干的进程之间进行通信，可以吗? ?——可以，用命名管道

• 匿名管道只能用于具有亲缘关系的进程间通信，命名管道可用于同一主机上的任意进程间通信
• 匿名管道的本质是内核中的缓冲区，命名管道文件是缓冲区的标识

1.命名管道原理

进程间通信的本质是:不同的进程要看到同一份资源。
匿名管道原理：通过利用 fork创建子进程，子进程能继承父进程的文件描述符表的特性 实现的。

命名管道原理:磁盘中的内存把 文件描述的结构体struct_file 加载到内存中，进程1打开此文件，引用计数加1；进程2打开此文件，遍历内核发现文件存在，引用计数变为2，两个进程可以看到同一份资源。两进程通信时在内存中通信，数据不会刷新到磁盘上，此文件只是一种符号

通过一个fifo文件->有路径->具有唯一性->通过路径，找到同一个资源!
磁盘

2.mkfifo 创建命名管道

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

作用：创建一个文件(命名管道)，路径pathname就是这个文件的路径（./.fifo）。

pathname：你要制作的文件的文件路径。mode：你要制作的文件的权限

返回值：创建成功返回0，创建失败返回-1

3.命名管道应用代码：

makefile

.PHONY:all
all: clientFifo serverFifo

clientFifo:clientFifo.cpp
	g++ -Wall -o $@ $^ -std=c++11

serverFifo:serverFifo.cpp
	g++ -Wall -o $@ $^ -std=c++11

.PHONY:clean
clean:
	rm -rf clientFifo serverFifo .fifo

comm.h

#pragma once

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

#define IPC_PATH "./.fifo"

clientFifo.cpp

//写入
#include "comm.h"

using namespace std;

int main()
{
    int pipeFd = open(IPC_PATH, O_WRONLY);
    if(pipeFd < 0)
    {
        cerr << "open: " << strerror(errno) << endl;
        return 1;
    }

#define NUM 1024
    char line[NUM];
    while(true)
    {
        printf("请输入你的消息# ");
        fflush(stdout);
        memset(line, 0, sizeof(line));
        // fgets -> C -> line结尾自动添加\0
        if(fgets(line, sizeof(line), stdin) != nullptr)
        {
            //abcd\n\0
            line[strlen(line) - 1] = '\0';
            write(pipeFd, line, strlen(line));
        }
        else
        {
            break;
        }
    }
    close(pipeFd);
    cout << "客户端退出啦" << endl;
    return 0;
}

serverFifo.cpp

//读取
#include "comm.h"

using namespace std;

int main()
{
    umask(0);
    if(mkfifo(IPC_PATH, 0600) != 0)
    {
        cerr << "mkfifo error" << endl;
        return 1;
    }

    int pipeFd = open(IPC_PATH, O_RDONLY);
    if(pipeFd < 0)
    {
        cerr << "open fifo error" << endl;
        return 2;
    }

#define NUM 1024
    //正常的通信过程
    char buffer[NUM];
    while(true)
    {
        ssize_t s = read(pipeFd, buffer, sizeof(buffer)-1);
        if(s > 0)
        {
            buffer[s] = '\0';
            cout << "客户端->服务器# " << buffer << endl;
        }
        else if(s == 0)
        {
            cout << "客户退出啦，我也退出把";
            break;
        }
        else
        {
            //do nothing
            cout << "read: " << strerror(errno) << endl;
            break;
        }
    }


    close(pipeFd);
    cout << "服务端退出啦" << endl;
    unlink(IPC_PATH);
    return 0;
}

注意点①：serverFifo.cpp中最后几句容易忘写：
    close(pipeFd);
    cout << "服务端退出啦" << endl;
    unlink(IPC_PATH);