0


匿名管道 Linux

管道

首先自己要用用户层缓冲区,还得把用户层缓冲区拷贝到管道里,(从键盘里输入数据到用户层缓冲区里面),然后用户层缓冲区通过系统调用(write)写到管道里,然后再通过read系统调用,被对方(读端)读取,就要从管道拷贝到读端,然后再显示到显示器上。

pipe创建一个管道

pipe的介绍

1完成这件事:

看图分析

运行结果

#include<iostream>
#include<unistd.h>
using namespace std;
int main()
{
    //创建管道
    //先创建一个pipefd数组
    int pipefd[2];
    //用n接受一下,判断是否成功
    int n = pipe(pipefd);
    if(n<0) return 1;//创建失败了

    //创建成功
    //测试一下文件描述符是3和4
    cout<<"pipefd[0]:"<<pipefd[0]<<"pipefd[1]:"<<pipefd[1]<<endl;
    

    return 0;
}

2完成这件事:

创建一个子进程

 pid_t id = fork();
    if(id < 0)return 2;//创建失败
    if(id == 0)//创建成功
    {
        //子进程

    }
    //父进程

让子进程写入,父进程读取

要想让子进程进程写,就需要在进程中关闭读端

if(id == 0)//创建成功
{
     //子进程
     close(pipefd[0]);
}

同理

//父进程
close(pipefd[1]);

都用完结束后,可以都关掉

    if(id == 0)//创建成功
    {
        //子进程
        close(pipefd[0]);
        //.....
        close(pipefd[1]);
    }
    //父进程
    close(pipefd[1]);
    //.....
    close(pipefd[0]);

IPC code,写通信代码

3这件事也完成了:

结构就有了

然后在pipefd[1]这个管道里写,定义一个Writer函数

    if(id == 0)//创建成功
    {
        //子进程
        close(pipefd[0]);
        //.....IPC code,写通信代码
        //在pipefd[1]这个管道里写
        Writer(pipefd[1]);

        close(pipefd[1]);

        exit(0);//正常退出
    }

同理父进程的

    //父进程
    close(pipefd[1]);
    //.....IPC code,写通信代码
    //在pipefd[0]这个管道里写
    Reader(pipefd[0]);

    close(pipefd[0]);

//子进程
void Writer(int wfd)
{

}
//父进程
void Reader(int rfd)
{

}

Writer

//子进程
void Writer(int wfd)
{
    string s = "hello,I am child";
    pid_t self = getpid();
    int number = 0;

    char buffer[10];
    while(true)
    {
        buffer[0] = 0;//字符串清空,只是为了提醒阅读代码的人,我把这个数组当字符串了

    }
}

用到snprintf
介绍

将s和self和number放进buffer

  char buffer[100];
    while(true)
    {
        buffer[0] = 0;//字符串清空,只是为了提醒阅读代码的人,我把这个数组当字符串了
        snprintf(buffer,sizeof(buffer),"%s    pid:%d\n",s.c_str(),self);
        cout<< buffer <<endl;
        sleep(1);
    };

用cout打印测试一下,打印成功说明写入buffer成功了

等待进程少不了,子进程exit后需要回收

 //父进程
    close(pipefd[1]);
    //.....IPC code,写通信代码
    //在pipefd[0]这个管道里写
    Reader(pipefd[0]);

    //等待进程缺少不了
    pid_t rid = waitpid(id,nullptr,0);
    if(rid < 0) return 3;//等待失败了

    close(pipefd[0]);

如何把消息发送/写入给父进程

用到了write

用write写入管道(管道也是文件),用strlen,不用+1,不用管\0,因为C语言规定\0结尾,和文件没有关系,wfd写入管道

//子进程
void Writer(int wfd)
{
    string s = "hello,I am child";
    pid_t self = getpid();
    int number = 0;
    char buffer[100];
    while(true)
    {
        buffer[0] = 0;//字符串清空,只是为了提醒阅读代码的人,我把这个数组当字符串了
        snprintf(buffer,sizeof(buffer),"%s    pid:%d  %d\n",s.c_str(),self,number++);
        //用write写入管道(管道也是文件),用strlen,不用+1,不用管\0,因为C语言规定\0结尾,和文件没有关系,wfd写入管道
        write(wfd,buffer,strlen(buffer));
        //cout<< buffer <<endl;
        sleep(1);
    };
}

父进程该怎么读取呢

用到了read,fd是文件描述符,从特定的文件描述符里读取,放在这个buf里,buf的长度是count

这里就需要考虑到\0,因为buffer中需要\0

//父进程
void Reader(int rfd)
{
    char buffer[100];
    while(true)
    {
        buffer[0] = 0;
                                    //用sizeof是为了留个空间放\0
        ssize_t n = read(rfd, buffer, sizeof(buffer));//sizeof!=strlen
        if(n > 0)
        {
            //添加\0,因为要放在buffer数组中读取
            buffer[n]=0;
            cout << "father get a message[" << getpid() <<"]"<< buffer <<endl;
        }
    }
}

运行结果

也会发现:为什么子进程sleep,父进程不sleep,父进程还是会跟着子进程sleep,因为父子进程是要协同的

管道本质

通信是为了更好的发送变化的数据,管道本质上是文件

所以必须要用到系统调用接口来访问管道,其是由系统管理,read和write

**,操作系统相当于中介 **

结论:管道的特征:

1:具有血缘关系的进程进行进程间通信

2:管道只能单向通信

3:父子进程是会进程协同的,同步与互斥的--保护管道文件的数据安全

4:管道是面向字节流的

5:管道是基于文件的,而文件的生命周期是随进程的

再测试,把子进程sleep去掉,就是让子进程写快一点,父进程sleep几秒,就是让父进程读慢一点,看有什么现象

管道的四种情况

测试管道大小

把c一直往管道里写,把父进程中休眠50秒

结果差不多64kb

写端退了,测试结果

结果是:

读端正常读,写端关闭,读端就会读到0,表明读到了文件(pipe)结尾,不会被阻塞

read读取成功会返回读到的字符个数,读到结尾返回0

读到结尾父进程也就可以停止读取了,break后去把僵尸的子进程回收

break到这里

最后子进程会被waitpid回收

测试子进程一直写,父进程读一会就退出

定义一个cnt控制退出的时间

这里也要修改一下,加个sleep(5),观察,close提前关闭

结果:通过13号信号杀死

管道到的应用场景

都会变成一个进程

写一个进程池(pipe_use)

首先创建好文件

创建5个进程

channel通道的意思

cmdfd文件描述符

slaverid代表哪个子进程

把它放进vector容器里

思路步骤

管道创建

void(n),假装使用一下,要不然编译不过

创建父子进程

父进程写,子进程读

子进程要读取,就要关闭自己的写端,父进程同理

子进程中的任务

子进程pid有了管道也有了,就差在父进程添加字段了

先更改一下,在class里构造一下

添加字段

测试一下:结果:文件描述符0,1,2是默认打开,3是从管道里读,4是写入管道

把初始化改造成函数

debug测试函数,纯输入函数

第二步开始控制进程了(想让子进程做什么)

这里打印的rfd都是3,正常吗,文件描述符是可以被子进程继承的

父进程对应的写端拿到的是4-8,子进程拿到的读端fd是3

改变一下,直接从键盘(0号描述符)里读,不从管道(3)里读了,就没有管道的概念了,slaver就不用传参了,父进程通过管道写,子进程通过标准输入读

用到了dup2,将从pipefd[0]中读变成从0开始读

想让父进程固定的向管道里写入指定大小字节的内容,必须读取四个字节,四个字节四个字节的写和读,这里的管道64kb

必须读取四个字节

如果父进程不给子进程发送数据呢?阻塞等待!

开始控制子进程

生成一个随机数种子

可以随机选择任务和选择进程

cmd是任务码,测试一下,父进程控制子进程,父进程发送给子进程(通过cmdcode连续)

在Task.hpp里

要用到函数指针

main中的任务了就属于

再把任务装载进来

输出型参数用*

现在开始选择任务和进程

再把main中的任务弄成全局的

进行判断一下

测试 ,comcode和任创建的任务一致

这里的write是父进程进行写入,向子进程发送,子进程不得闲,先写到管道里,等得闲了再读

也可以轮询选择,定义一个计数器,++弄,再%等

整理一下控制代码,这里是输入型参数,只需要读

这样就可以轮询方式选择进程了,不用随机了

结果

清理收尾

思路:把所有文件的描述符都关掉

等待方式设置为0

read返回0,就是失败了,然后slaver就会调完

结束完就会exit直接退出

打印下更好显示

关闭文件描述符后sleep(10)秒,

然后这10个子进程一瞬间都应该break,然后最后到exit直接就退了,10秒结束后,父进程再回收他

测试时不弄死循环,用cnt,5秒后自动结束控制,正常退出流程

测试结果

手动控制一下

定义一个select,输入0就是退出了,判断完后,就走到了选择任务


然后直接把cmdcode改为选择的select,-1是因为是从下标0开始的,输入1就是0下标的

测试

bug的地方:

这样会有一些bug(一个子进程不是只有一个写端(每一次子进程的创建都是有继承))

这样会有一些bug(一个子进程不是只有一个写端(每一次子进程的创建都是有继承))

按理说这样是对的,可是这样就错了

因为下面两个红线还没有关掉,它们进程了最开始的w

这样倒着回收是可以的

正确改法

修改一下

最后一个push_back的就都是父进程的写入fd,

然后加一句这个红线的,每创建子进程后都先把上一次父进程的读端fd关掉就可以了,这里很妙,因为vector一开始是空的

方便看

这里这样就可以了

管道已经完成

以上是匿名管道

总文件总代码

makefile中代码

ProcessPool:ProcessPool.cc
    g++ -o $@ $^ -std=c++11
.PHNOY:clean
clean:
    rm -f ProcessPool

Task.hpp中代码

#pragma once

#include<iostream>
#include<vector>

using namespace std;

typedef void (*task_t)();

void task1()
{
    cout<< "lol 刷新日志" <<endl;
}

void task2()
{
    cout<< "lol 更新野区" <<endl;
}

void task3()
{
    cout<< "lol 检测软件更新" <<endl;
}

void task4()
{
    cout<< "lol 释放技能" <<endl;
}

ProcessPool.cc中代码

#include "Task.hpp"
#include<iostream>
#include<string>
#include<vector>
#include<unistd.h>
#include<assert.h>
#include <sys/types.h>
#include <sys/wait.h>
using namespace std;

//打算创建5个进程
const int processnum = 5;
//全局任务
vector<task_t> tasks;

//先描述
class channel//管道
{ 
public:
    channel(int cmdfd,pid_t slaverid,string& processname)
    :_cmdfd(cmdfd)
    ,_slaverid(slaverid)
    ,_processname(processname)
    {}

public:
    int _cmdfd;//文件描述符
    pid_t _slaverid;//代表哪个子进程
    string _processname;//子进程的名字,方便打印日志
};

//子进程中读的任务
// void slaver(int rfd)
// {
//     while(true)
//     {
//         cout<< getpid() <<" - "<< "read fd is->"<<rfd<<endl;
//         sleep(1000);
//     }
// }
//改变一下从fd为0的地方开始读
void slaver()
{
    //read(0);
    while(true)
    {
        int cmdcode = 0;
        int n = read(0, &cmdcode, sizeof(int));
        if(n == sizeof(int))
        {
            //执行cmdcode对应的任务列表
            cout<< "slaver say@ get a command:" << getpid() << ":cmdcode:" << cmdcode <<endl;

            //判断一下并执行
            if(cmdcode >= 0 && cmdcode < tasks.size())  tasks[cmdcode]();
        }
        if(n == 0) break;
    }
}

//初始化
void Init(vector<channel>& channels)
{
    for(int i =0;i < processnum;i++)
    {
        int pipefd[2];
        int n = pipe(pipefd);//创建管道
        //返回值小于0就创建失败了
        assert(!n);
        (void)n;

        pid_t id = fork();
        if(id == 0)
        {
            //子进程:读
            close(pipefd[1]);

            //改变一下从fd为0的地方读
            dup2(pipefd[0],0);
            close(pipefd[0]);
            //任务
            slaver();
            cout<< "process: " << getpid() << "quit" <<endl;
            //slaver(pipefd[0]);

            exit(0);
        }
        //父进程:写
        close(pipefd[0]);
        //channel添加字段
        string name = "processs-" + to_string(i);
        //插入的是自定义类型,要构造一下,第一个传的是文件描述符,要写入的fd
        channels.push_back(channel(pipefd[1], id, name));
    }
}
//测试函数,纯输入函数
//输入:const &
//输出:*
//输入输出:&
void debug(const vector<channel>& channels)
{
    for(auto&e : channels)
    {
        cout<< e._cmdfd <<"  "<<e._slaverid<<"   "<<e._processname<<endl;
    }

}

void Loadtask(vector<task_t> *tasks)
{   
    tasks->push_back(task1);
    tasks->push_back(task2);
    tasks->push_back(task3);
    tasks->push_back(task4);
}
void memu()
{
    cout<< "########################" <<endl;
    cout<< "1:lol 刷新日志     2:lol 更新野区" <<endl;
    cout<< "1:lol 检测软件更新   4:lol 释放技能" <<endl;
    cout<< "           0:退出             " <<endl;
    cout<< "########################" <<endl;
}
//2:开始控制子进程
void ctrlSlaver(vector<channel> &channels)
{
    int which = 0;
    int cnt = 5;
    while(true)
    {
        int select = 0;
        memu();
        cout<< "Please Enter@:";
        cin>> select;
        if(select == 0) break;
        //1:选择任务
        //int cmdcode = rand()%tasks.size();
        int cmdcode = select - 1;

        //2:随机选择进程
        //int processpos = rand()%channels.size();
        
        //2:轮询选择进程
        cout<< "father say:"<< "cmdcode:" << cmdcode << "   already sendto  " <<channels[which]._slaverid << "process name   " 
            <<channels[which]._processname << endl;

        //3:发送任务
        write(channels[which]._cmdfd, &cmdcode, sizeof(cmdcode));
        which++;
        which%=channels.size();//保证不大于其长度
        cnt--;
        if(cnt == 0) break;
        sleep(1);
    }
}
void QuitProcess(const vector<channel> &channels)
{
    for(const auto& e : channels) close(e._cmdfd);
    sleep(10);
    for(const auto& e : channels) waitpid(e._slaverid, nullptr, 0);//进程的pid=_slaverid,关上了以后记得回收
}

int main()
{
    Loadtask(&tasks);

    //srand(time(nullptr)^getpid()^1023);//种一个随机数种子
    //在组织
    vector<channel> channels;
    //1:初始化
    Init(channels);

    debug(channels);

    //2:开始控制子进程
    ctrlSlaver(channels);

    //3:清理收尾
    QuitProcess(channels);

    return 0;
}
标签: 算法 数据结构 c++

本文转载自: https://blog.csdn.net/2401_83427936/article/details/142602799
版权归原作者 Ljw... 所有, 如有侵权,请联系我们删除。

“匿名管道 Linux”的评论:

还没有评论