Linux——利用命名管道创建进程池

最新推荐文章于 2024-11-05 18:02:41 发布
最新推荐文章于 2024-11-05 18:02:41 发布
阅读量636 收藏 13
点赞数 23
分类专栏： Linux操作系统 文章标签： linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_67693066/article/details/137052640
版权

Linux——利用命名管道创建进程池

我们之前简单介绍了一下命名管道，我们今天来利用命名管道来创建一个进程池，之前我们利用过匿名管道创建过进程池，如果有小伙伴感兴趣可以点击这里：

https://blog.csdn.net/qq_67693066/article/details/136454164

这里其实没有啥新鲜的事情，但是通过这个可以帮助我们在面对问题时如何着手一步一步解决，培养我们的能力：

第一步：创建管道

进程池的第一步，你得有管道呀，所以我们编写一个函数来创建一批命名管道：

#pragma once
#include<sstream>
#include<unistd.h>
#include<fcntl.h>
#include<sys/stat.h>

//这里我们先创建5个命名管道
#define MY_CHANNEL_NUMBER 10

//管道的基本名字
const std::string base_name = "../my_fifo";

//创建管道
void CreateChannels()
{
    for(int i = 0; i < MY_CHANNEL_NUMBER; i++)
    {
        std::stringstream ss; //标准流对象
        ss<< base_name <<"_"<< i; //在基本名字之后加上序号来给管道标号

        std::string name = ss.str();

        if(mkfifo(name.c_str(),0666) == -1)
        {
            perror("create channels fail");
            continue;
        }
    }
}

我们在主函数中测试一下：

#include"ProcessPool.hpp"

int main()
{
    CreateChannels();
}

在这里插入图片描述
这个时候有一个问题，如果我们的管道已经创建好了，那么重复创建肯定是不行的，这个时候我们用errno（C/C++ 编程中用于表示系统级错误的一个全局变量）来保存我们的错误代号，如果是管道已经存在，errno会储存错误信息，帮助我们判断：

#pragma once
#include<sstream>
#include<unistd.h>
#include<fcntl.h>
#include<sys/stat.h>
#include<iostream>
#include<cerrno>

//这里我们先创建5个命名管道
#define MY_CHANNEL_NUMBER 10

//管道的基本名字
const std::string base_name = "../my_fifo";

//创建管道
void CreateChannels()
{
    for(int i = 0; i < MY_CHANNEL_NUMBER; i++)
    {
        std::stringstream ss; //标准流对象
        ss<< base_name <<"_"<< i; //在基本名字之后加上序号来给管道标号

        std::string name = ss.str();

        if(mkfifo(name.c_str(),0666) == -1)
        {
            if(errno != EEXIST)
            {
                  perror("create channels fail");
                  exit(EXIT_FAILURE);
            }
            else
            {
                 std::cout<<"channel has existed"<<std::endl;
            }
          
        }
        else
        {
            //如果你成功什么都不做
        }
    }
}

在这里插入图片描述

第二步：批量删除管道

现在我们创建好了管道，我们如果不想要了，我们要把它们删除。所以我们编写一个函数来批量删除管道：

void DeletePipes()
{
    for(int i = 0; i < MY_CHANNEL_NUMBER; i++)
    {
         std::stringstream ss; //标准流对象
        ss<< base_name <<"_"<< i; //在基本名字之后加上序号来给管道标号

        std::string name = ss.str();

        if(unlink(name.c_str())==-1)
        {
            if(errno == ENOENT) //如果管道本身不存在
            {
                std::cout<<name<<"not exits"<<std::endl;
            }
            else
            {
                perror("unlink fail");
                exit(EXIT_FAILURE);
            }
        }
    }
}

我们测试一下：

#include"ProcessPool.hpp"

int main()
{
    //创建管道
    CreateChannels();
    
    //删除管道
    DeletePipes();

}

在这里插入图片描述
看到管道确实被删除了。

第三步：封装管道，使之容易被管理

不知道大家发现没有，我们在创建管道，删除管道的时候还要自己写管道路径
在这里插入图片描述

在这里插入图片描述
这样子稍微有点麻烦，既然这样，我们还不如把管道设计称为一个类，方便我们管理：

#pragma once
#include<sstream>
#include<unistd.h>
#include<fcntl.h>
#include<sys/stat.h>
#include<iostream>
#include<cerrno>
#include<vector>

//这里我们先创建5个命名管道
#define MY_CHANNEL_NUMBER 10


//管道的基本名字
const std::string base_name = "../my_fifo";

//管道类
struct Channel
{
    Channel(const std::string fifo_name)
        :fifo_path(fifo_name)
    {
       
    }


    // 管道路径
    std::string fifo_path; 
};



//创建管道
void CreateChannels(std::vector<Channel>* channels)
{
    for(int i = 0; i < MY_CHANNEL_NUMBER; i++)
    {
        std::stringstream ss; //标准流对象
        ss<< base_name <<"_"<< i; //在基本名字之后加上序号来给管道标号
        
        //创建Channel
        Channel channel(ss.str()); //初始化一个chennel（管道）
        

        if(mkfifo(channel.fifo_path.c_str(),0666) == -1)
        {
            if(errno != EEXIST)
            {
                perror("create channels fail");
                break;
            }
            else
            {
                std::cout<<"channel has existed"<<std::endl;
                channels->push_back(channel); //已经存在也要放进去
            }
        
            }
        else
        {
            //如果你成功，则添加到vector里
            channels->push_back(channel);
        }
    }
}


void DeletePipes(std::vector<Channel>& channels)
{
    for(auto& e : channels)
    {
        if(unlink(e.fifo_path.c_str())==-1)
        {
            if(errno == ENOENT) //如果管道本身不存在
            {
                std::cout<<e.fifo_path<<"not exits"<<std::endl;
            }
            else
            {
                perror("unlink fail");
                exit(EXIT_FAILURE);
            }
        }
        else
        {
            std::cout<<"suecessful delete"<<std::endl;
        }
    }
}

第四步：模拟进程通信

我们现在有了管道，现在我们模拟一下进程之间的通信，这里我们就用父子进程进行通信，父进程往管道写入命令，子进程从管道当中读取并执行命令：

void DoingWork(const std::vector<Channel>& channels,const std::string work_name)
{
    
    //选择一个管道进行工作
    Channel one = ChooseChannel(channels);

    //创建子进程
    pid_t id = fork();

    if(id == 0) 
    {
        if(access(one.fifo_path.c_str(),F_OK) == -1)
        {
            std::cout<<"channel has be deleted"<<std::endl;
            exit(EXIT_SUCCESS);
        }
        else
        {
            int rfd = open(one.fifo_path.c_str(),O_RDONLY); 
            if(rfd < 0)
            {
                perror("read fail");
                exit(EXIT_FAILURE);
            }
            else
            {
                //子进程从管道当中读数据
                char buffer[1024];
                ssize_t number = read(rfd,buffer,sizeof(buffer));

                if(number > 0)
                {
                    buffer[number] = '\0';
                }

                //读取之后执行任务
                Work(buffer);

                //任务结束后关闭读端
                close(rfd);
            }
        }
  


    }
    else if(id > 0) // 父进程
    {
        //以写方式打开
        if(access(one.fifo_path.c_str(),F_OK) == -1)
        {
            std::cout<<"channel has be deleted"<<std::endl;
            exit(EXIT_SUCCESS);;
        }
        else
        {
             int wfd = open(one.fifo_path.c_str(),O_WRONLY);

            if(wfd < 0)
            {
                perror("write fail");
                exit(EXIT_FAILURE);
            }
            else
            {
                //往管道里面写入
                //我们用一个vector存放string来模拟任务的场景

                ssize_t number = write(wfd,work_name.c_str(),strlen(work_name.c_str()));

                if(number < 0)
                {
                    perror("write fail");
                    exit(EXIT_FAILURE);
                }

                //关闭读端
                close(wfd);

                //回收子进程
                waitpid(id,nullptr,0); 
            }

        }
       
    }
    else
    {
        perror("fork fail");
        exit(EXIT_FAILURE);
    }
}

选择管道函数和选择任务函数

const Channel& ChooseChannel(const std::vector<Channel>& channels)
{
    // 创建一个随机数引擎

    std::random_device rd; // 用于获取高质量的随机数种子

    std::mt19937 gen(rd()); // 使用随机设备生成的种子初始化MT19937引擎


    // 创建一个均匀分布的整数分布对象
    std::uniform_int_distribution<> dis(0, channels.size()-1);


    // 生成随机数并输出
    int number = dis(gen);
    return channels[number];
}

const std::string  SeleteWork()
{
    // 创建一个随机数引擎

    std::random_device rd; // 用于获取高质量的随机数种子
    std::mt19937 gen(rd()); // 使用随机设备生成的种子初始化MT19937引擎

    // 创建一个均匀分布的整数分布对象
    std::uniform_int_distribution<> dis(0, task_list.size()-1);

    // 生成随机数并输出
    int number = dis(gen);

    return task_list[number];
}

这里为了简便，我使用了vector储存字符串，来模拟任务列表，SeleteWork负责从中挑选工作：

//用来模拟任务
std::vector<std::string> task_list = {"dowload","movie","music","games","learning"};

整体代码

#pragma once
#include<sstream>
#include<unistd.h>
#include<fcntl.h>
#include<sys/stat.h>
#include<iostream>
#include<cerrno>
#include<vector>
#include<sys/wait.h>
#include<random>
#include<cstring>
#include<ctime>

//这里我们先创建5个命名管道
int MY_CHANNEL_NUMBER = 10;

//用来模拟任务
std::vector<std::string> task_list = {"dowload","movie","music","games","learning"};


//管道的基本名字
const std::string base_name = "../my_fifo";

//管道类
struct Channel
{
    Channel(const std::string fifo_name)
        :fifo_path(fifo_name)
    {
       
    }


    // 管道路径
    std::string fifo_path; 
};



//创建管道
void CreateChannels(std::vector<Channel>* channels)
{
    for(int i = 0; i < MY_CHANNEL_NUMBER; i++)
    {
        std::stringstream ss; //标准流对象
        ss<< base_name <<"_"<< i; //在基本名字之后加上序号来给管道标号
        
        //创建Channel
        Channel channel(ss.str()); //初始化一个chennel（管道）
        

        if(mkfifo(channel.fifo_path.c_str(),0666) == -1)
        {
            if(errno != EEXIST)
            {
                perror("create channels fail");
                break;
            }
            else
            {
                std::cout<<"channel has existed"<<std::endl;
                channels->push_back(channel); //已经存在也要放进去
            }
        
            }
        else
        {
            //如果你成功，则添加到vector里
            channels->push_back(channel);
        }
    }
}


void DeletePipes(std::vector<Channel>& channels)
{
    for(auto& e : channels)
    {
        if(unlink(e.fifo_path.c_str())==-1)
        {
            if(errno == ENOENT) //如果管道本身不存在
            {
                std::cout<<e.fifo_path<<" not exits"<<std::endl;
            }
            else
            {
                perror("unlink fail");
                exit(EXIT_FAILURE);
            }
        }
        else
        {
            std::cout<<"suecessful delete"<<std::endl;
            MY_CHANNEL_NUMBER--;
            if(MY_CHANNEL_NUMBER == 0)
            {
                std::cout<<"channels have cleared"<<std::endl;
                exit(EXIT_SUCCESS);
            }

        }
    }
}

const Channel& ChooseChannel(const std::vector<Channel>& channels)
{
    // 创建一个随机数引擎

    std::random_device rd; // 用于获取高质量的随机数种子

    std::mt19937 gen(rd()); // 使用随机设备生成的种子初始化MT19937引擎


    // 创建一个均匀分布的整数分布对象
    std::uniform_int_distribution<> dis(0, channels.size()-1);


    // 生成随机数并输出
    int number = dis(gen);
    return channels[number];
}

void Work(const char* buffer)
{
    std::cout<<"doing "<<buffer<<std::endl;
}


const std::string  SeleteWork()
{
    // 创建一个随机数引擎

    std::random_device rd; // 用于获取高质量的随机数种子
    std::mt19937 gen(rd()); // 使用随机设备生成的种子初始化MT19937引擎

    // 创建一个均匀分布的整数分布对象
    std::uniform_int_distribution<> dis(0, task_list.size()-1);

    // 生成随机数并输出
    int number = dis(gen);

    return task_list[number];
}


void DoingWork(const std::vector<Channel>& channels,const std::string work_name)
{
    
    //选择一个管道进行工作
    Channel one = ChooseChannel(channels);

    //创建子进程
    pid_t id = fork();

    if(id == 0) 
    {
        if(access(one.fifo_path.c_str(),F_OK) == -1)
        {
            std::cout<<"channel has be deleted"<<std::endl;
            exit(EXIT_SUCCESS);
        }
        else
        {
            int rfd = open(one.fifo_path.c_str(),O_RDONLY); //判断管道是否存在，不存在则退出，存在则打开
            if(rfd < 0)
            {
                perror("read fail");
                exit(EXIT_FAILURE);
            }
            else
            {
                //子进程从管道当中读数据
                char buffer[1024];
                ssize_t number = read(rfd,buffer,sizeof(buffer));

                if(number > 0)
                {
                    buffer[number] = '\0';
                }

                //读取之后执行任务
                Work(buffer);

                //任务结束后关闭读端
                close(rfd);
            }
        }
  


    }
    else if(id > 0) // 父进程
    {
        //以写方式打开
        if(access(one.fifo_path.c_str(),F_OK) == -1)
        {
            std::cout<<"channel has be deleted"<<std::endl;
            exit(EXIT_SUCCESS);;
        }
        else
        {
             int wfd = open(one.fifo_path.c_str(),O_WRONLY);

            if(wfd < 0)
            {
                perror("write fail");
                exit(EXIT_FAILURE);
            }
            else
            {
                //往管道里面写入
                //我们用一个vector存放string来模拟任务的场景

                ssize_t number = write(wfd,work_name.c_str(),strlen(work_name.c_str()));

                if(number < 0)
                {
                    perror("write fail");
                    exit(EXIT_FAILURE);
                }

                //关闭读端
                close(wfd);

                //回收子进程
                waitpid(id,nullptr,0); 
            }

        }
       
    }
    else
    {
        perror("fork fail");
        exit(EXIT_FAILURE);
    }
}

#include"ProcessPool.hpp"

int main()
{
    srand(time(0));
    std::vector<Channel> channels;

    //创建管道
    CreateChannels(&channels);


    //进行交互
    for(int i = 0; i < 10; i++)
    {
        std::string work = SeleteWork();
        DoingWork(channels,work);
    }
    
    //删除管道
    DeletePipes(channels);

}

在这里插入图片描述

最后一步：实现类的封装

最后，我们这些过程可以都包含在主程序类中，封装所有函数，方便维护：

class MainProcess //主程序类
{
public:
     

private:
    std::vector<Channel> channels;
};

公共接口放我们所有的函数（除了work函数）：

#pragma once
#include<sstream>
#include<unistd.h>
#include<fcntl.h>
#include<sys/stat.h>
#include<iostream>
#include<cerrno>
#include<vector>
#include<sys/wait.h>
#include<random>
#include<cstring>
#include<ctime>

//这里我们先创建5个命名管道
int MY_CHANNEL_NUMBER = 10;

//用来模拟任务
std::vector<std::string> task_list = {"dowload","movie","music","games","learning"};


//管道的基本名字
const std::string base_name = "../my_fifo";

//管道类
struct Channel
{
    Channel(const std::string fifo_name)
        :fifo_path(fifo_name)
    {
       
    }


    // 管道路径
    std::string fifo_path; 
};



void Work(const char* buffer)
{
    std::cout<<"doing "<<buffer<<std::endl;
}



class MainProcess //主程序类
{
public:
     //创建管道
    void CreateChannels()
    {
        for(int i = 0; i < MY_CHANNEL_NUMBER; i++)
        {
            std::stringstream ss; //标准流对象
            ss<< base_name <<"_"<< i; //在基本名字之后加上序号来给管道标号
            
            //创建Channel
            Channel channel(ss.str()); //初始化一个chennel（管道）
            

            if(mkfifo(channel.fifo_path.c_str(),0666) == -1)
            {
                if(errno != EEXIST)
                {
                    perror("create channels fail");
                    break;
                }
                else
                {
                    std::cout<<"channel has existed"<<std::endl;
                    channels.push_back(channel); //已经存在也要放进去
                }
            
                }
            else
            {
                //如果你成功，则添加到vector里
                channels.push_back(channel);
            }
        }
    }


    void DeletePipes()
    {
        for(auto& e : channels)
        {
            if(unlink(e.fifo_path.c_str())==-1)
            {
                if(errno == ENOENT) //如果管道本身不存在
                {
                    std::cout<<e.fifo_path<<" not exits"<<std::endl;
                }
                else
                {
                    perror("unlink fail");
                    exit(EXIT_FAILURE);
                }
            }
            else
            {
                std::cout<<"suecessful delete"<<std::endl;
                MY_CHANNEL_NUMBER--;
                if(MY_CHANNEL_NUMBER == 0)
                {
                    std::cout<<"channels have cleared"<<std::endl;
                    exit(EXIT_SUCCESS);
                }

            }
        }
    }

    const Channel& ChooseChannel()
    {
        // 创建一个随机数引擎

        std::random_device rd; // 用于获取高质量的随机数种子

        std::mt19937 gen(rd()); // 使用随机设备生成的种子初始化MT19937引擎


        // 创建一个均匀分布的整数分布对象
        std::uniform_int_distribution<> dis(0, channels.size()-1);


        // 生成随机数并输出
        int number = dis(gen);
        return channels[number];
    }


    const std::string  SeleteWork()
    {
        // 创建一个随机数引擎

        std::random_device rd; // 用于获取高质量的随机数种子
        std::mt19937 gen(rd()); // 使用随机设备生成的种子初始化MT19937引擎

        // 创建一个均匀分布的整数分布对象
        std::uniform_int_distribution<> dis(0, task_list.size()-1);

        // 生成随机数并输出
        int number = dis(gen);

        return task_list[number];
    }


    void DoingWork(const std::string work_name)
    {
        
        //选择一个管道进行工作
        Channel one = ChooseChannel();

        //创建子进程
        pid_t id = fork();

        if(id == 0) 
        {
            if(access(one.fifo_path.c_str(),F_OK) == -1) //判断管道是否存在，不存在则退出，存在则打开
            {
                std::cout<<"channel has be deleted"<<std::endl;
                exit(EXIT_SUCCESS);
            }
            else
            {
                int rfd = open(one.fifo_path.c_str(),O_RDONLY); 
                if(rfd < 0)
                {
                    perror("read fail");
                    exit(EXIT_FAILURE);
                }
                else
                {
                    //子进程从管道当中读数据
                    char buffer[1024];
                    ssize_t number = read(rfd,buffer,sizeof(buffer));

                    if(number > 0)
                    {
                        buffer[number] = '\0';
                    }

                    //读取之后执行任务
                    Work(buffer);

                    //任务结束后关闭读端
                    close(rfd);
                }
            }
    


        }
        else if(id > 0) // 父进程
        {
            //以写方式打开
            if(access(one.fifo_path.c_str(),F_OK) == -1)
            {
                std::cout<<"channel has be deleted"<<std::endl;
                exit(EXIT_SUCCESS);;
            }
            else
            {
                int wfd = open(one.fifo_path.c_str(),O_WRONLY);

                if(wfd < 0)
                {
                    perror("write fail");
                    exit(EXIT_FAILURE);
                }
                else
                {
                    //往管道里面写入
                    //我们用一个vector存放string来模拟任务的场景

                    ssize_t number = write(wfd,work_name.c_str(),strlen(work_name.c_str()));

                    if(number < 0)
                    {
                        perror("write fail");
                        exit(EXIT_FAILURE);
                    }

                    //关闭读端
                    close(wfd);

                    //回收子进程
                    waitpid(id,nullptr,0); 
                }

            }
        
        }
        else
        {
            perror("fork fail");
            exit(EXIT_FAILURE);
        }
    }

private:
   std::vector<Channel> channels;
};

#include"ProcessPool.hpp"

int main()
{
    srand(time(0));
    //std::vector<Channel> channels;

    //创建管道
    //CreateChannels(&channels);
    MainProcess mainProcess;
    mainProcess.CreateChannels();


    //进行交互
    for(int i = 0; i < 10; i++)
    {
        std::string work = mainProcess.SeleteWork();
        mainProcess.DoingWork(work);
    }
    
    
    //删除管道
    mainProcess.DeletePipes();

}

在这里插入图片描述
如果大家还想复杂的话，可以把work函数在实现的复杂一点，使之更加智能。

落水 zh
关注
专栏目录
linux——FIFO命名管道（创建管道，生成特殊文件）
2302_76515999的博客
04-10 409
一旦创建一个FIFO，就可以用一般的文件I/O（open、read、write）函数操作它。2、FIFO有路径名与之相关联，它以一种特殊设备文件形式存在于文件系统中。当文件夹中没有file文件时，创建file并提示创建成功；1、FIFO可以在无关进程之间交换数据，与无名管道不同。3、最终修改为不管文件夹有没有file文件，都不报错，也不报成功。编译运行，ls -l 可以看到生成一个file文件。FIFO，也称为命名管道，它是一种文件类型。api原型：(man 3 mkfifo查看)
Linux进程间通信——使用命名管道
热门推荐
ljianhui的专栏
08-23 8万+
在前一篇文章——Linux进程间通信——使用匿名管道中，我们看到了如何使用匿名管道来在进程之间传递数据，同时也看到了这个方式的一个缺陷，就是这些进程都由一个共同的祖先进程启动，这给我们在不相关的的进程之间交换数据带来了不方便。这里将会介绍进程的另一种通信方式——命名管道，来解决不相关进程间的通信问题。 一、什么是命名管道 命名管道也被称为FIFO文件，它是一种特殊类型的文件，它在文件系
Linux——匿名管道、命名管道及进程池概念和实现原理
weixin_61857742的博客
12-04 2704
管道是linux中一种非常古老的进程间通信方式，本质上就是一个内存级的文件。一般用于父子进程间通信。概念上就是父进程与子进程共同使用一个管道文件来传输数据。虽然父子进程都有对管道的读和写功能，但在使用时只能读或者写，因此管道是单向通信，半双工模式。
Linux进程间通信——匿名管道|命名管道
m0_70289867的博客
12-15 1203
匿名管道 命名管道
【hello Linux】进程间通信——命名管道
qq_52842680的博客
04-27 1013
命令行的命名管道、命名管道的创建、 命名管道的使用
Linux——命名管道
m0_72165281的博客
05-04 786
linux——命名管道
Linux进程间通信——命名管道
JayceSun的博客
05-10 972
目录mkfifo命名管道命名管道与匿名管道的区别命名管道实现进程间通信示例client.cserver.c如何让Makefile编译多个文件 mkfifo 现在先通过这段命令来创建一个FIFO文件 mkfifo fifo 接着我们会发现目录下出现了这个文件 开始的"p"代表"fifo"是一个管道文件，接下来我们创建两个进程，一个向fifo写数据，另一个从fifo读数据 命名管道 进程间的通信根本就是要让不同的进程看到同一份资源，而匿名管道利用的是子进程继承父进程资源的特性，让他们看到同一份资源。那么
linux进程间通信——命名管道、 日志程序
strive_mianyang的博客
09-16 1153
linux进程间通信——命名管道的原理， 使用!!!!
【Linux学习】进程间通信——匿名管道 | 命名管道
weixin_63726869的博客
03-14 1854
介绍了进程间通信的相关概念，详细讲解了匿名管道和命名管道的工作原理和代码实现。还有详细介绍了进程池小项目。
Linux进程间通信4——使用命名管道.doc
04-30
为了解决这一问题，本篇将介绍一种更为灵活的进程间通信机制——命名管道（Named Pipe 或 FIFO）。 #### 二、命名管道简介 ##### 2.1 定义 命名管道是一种特殊类型的文件，也称为FIFO文件。与匿名管道不同，命名...
linux 命名管道实例详解
01-10
linux进程间通信——命名管道  FIFO（命名管道）不同于匿名管道之处在于它提供⼀个路径名与之关联，以FIFO的⽂件形式存储于⽂件系统中。命名管道是⼀个设备⽂件，因此，即使进程与创建FIFO的进程不存在亲缘关系，...
进程间通信——命名管道
h1091068389的博客
05-06 3494
命名管道命名管道定义命名管道创建命令行上创建程序内创建命名管道间通信匿名管道和命名管道区别 命名管道定义 上一篇博客中介绍了匿名管道的用法以及他的特点，但是它存在一定的限制，例如他只能在两个具有公共祖先的进程间进行通信例如父子进程。但是如果想要在不相关的两个进程之间进行数据交互，这可以使用命名管道。命名管道是一种特殊类型的文件 命名管道创建 命令行上创建 创建命名管道可以直接在命令行上使用mkfifo命令来创建。 创建结果如下，注意的是这里的文件类型是以p开头的。 为了测试这个管道功能，可以将Linux
Linux下的systemd/service
最新发布
zxz_Fine的博客
11-05 282
开机自启任务
Linux：网络协议socket
Au_ust的博客
11-05 732
我们之前学的通信是本地进程间通信，如果我们想在网络间通信的话，就需要用到二者的ip地址，分别被称为源IP地址和目的IP地址，被存入ip数据包中，其次我们还需要遵循一些通信协议。TCP协议：传输层协议，有连接，可靠传输，面向字节流（无明确边界的字节序列），难UDP协议：传输层协议，无连接，不可靠传输，面向数据流（以数据包为单位），简单网络通信的本质也是进程间通信，你怎么知道你要和哪个进程通信？
Linux初阶——线程（Part3）：POSIX 信号量 & CP 模型变体
m0_73093743的博客
11-02 445
只能建立一个对象的设计模式。
[linux 驱动]PWM子系统详解
weixin_49406449的博客
11-04 689
搜索“rockchip,rk3328-pwm”，发现在./drivers/pwm/pwm-rockchip.c 出现，所以 pwm6 的驱动是pwm-rockchip。任何 PWM 设备实例都可以被注册到 pwm_class 下，用户空间应用可以通过 /sys/class/pwm 访问这些设备，实现对 PWM 功能的控制。struct pwm_device *pwm: 这是指向 PWM 设备结构体的指针，该结构体是在调用 pwm_request 函数时获取的。这是指向该控制器的 PWM 通道的数组或链表。
Linux——Linux基础指令
辰多代码的博客
11-05 464
比 more 更强大的分页器，支持前后翻页和搜索。1：移动文件或目录（前提是目标文件或目录不存在）。：重命名文件或目录（前提是目标文件或目录存在）。:：显示系统上当前登录的用户及其相关信息。：显示网络连接、路由表和网络接口统计信息。：统计文件的行数、字数和字节数。：显示当前工作目录的完整路径。：列出目录中的文件和子目录。：显示或设置系统日期和时间。：在目录层次结构中搜索文件。：显示系统中正在运行的进程。：配置或显示网络接口信息。：显示当前用户的用户名。：更新现有文件的时间戳。：查找可执行文件的位置。
Linux 之 信号概念、进程、进程间通信、线程、线程同步
挥剑决浮云的博客
11-01 687
如果释放互斥锁时有一个以上的线程阻塞，那么这些阻塞的线程会被唤醒，它们都会尝试对互斥锁进行加锁，当有一个线程成功对互斥锁上锁之后，其它线程就不能再次上锁了，只能再次陷入阻塞，等待下一次解锁。事实上，子进程是父进程的一个副本，譬如子进程拷贝了父进程的数据段、堆、栈以及继承了父进程打开的文件描述符，父进程与子进程并不共享这些存储空间，这是子进程对父进程相应部分存储空间的完全复制，执行fork()之后，每个进程均可修改各自的栈数据以及堆段中的变量，而并不影响另一个进程。是一族函数，而不是一个单独的函数。
『 Linux 』网络传输层 - TCP(二)
小侯宝的博客
11-01 959
为什么是三次握手三次握手是TCP为了保证双方通信时具有可靠性所定制的一种策略;而三次握手可以确保客户端和服务端至少都向对方发送了一次消息,从而确保连接建立的更为可靠;以朴素的角度来看三次握手实际上也可以被解析成四次握手;但为了提升连接创建的效率,TCP采用捎带应答的策略,在第二次握手中将ACK报文与SYN报文整合成了一个报文,即为SYN+ACK报文;在三次握手中能够确保双端都对对方进行一次消息的发送以及消息的接收来确保连接的稳定,因此三次握手中任何一次握手都不能少;
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值