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

最新推荐文章于 2024-06-16 23:26:06 发布
最新推荐文章于 2024-06-16 23:26:06 发布
阅读量614 收藏 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
关注
  • 23
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux进程间通信——使用命名管道
ljianhui的专栏
08-23 8万+
在前一篇文章——Linux进程间通信——使用匿名管道中，我们看到了如何使用匿名管道来在进程之间传递数据，同时也看到了这个方式的一个缺陷，就是这些进程都由一个共同的祖先进程启动，这给我们在不相关的的进程之间交换数据带来了不方便。这里将会介绍进程的另一种通信方式——命名管道，来解决不相关进程间的通信问题。 一、什么是命名管道 命名管道也被称为FIFO文件，它是一种特殊类型的文件，它在文件系
Linux——匿名管道、命名管道及进程池概念和实现原理
weixin_61857742的博客
12-04 2189
管道是linux中一种非常古老的进程间通信方式，本质上就是一个内存级的文件。一般用于父子进程间通信。概念上就是父进程与子进程共同使用一个管道文件来传输数据。虽然父子进程都有对管道的读和写功能，但在使用时只能读或者写，因此管道是单向通信，半双工模式。
linux——FIFO命名管道（创建管道，生成特殊文件）
2302_76515999的博客
04-10 347
一旦创建一个FIFO，就可以用一般的文件I/O（open、read、write）函数操作它。2、FIFO有路径名与之相关联，它以一种特殊设备文件形式存在于文件系统中。当文件夹中没有file文件时，创建file并提示创建成功；1、FIFO可以在无关进程之间交换数据，与无名管道不同。3、最终修改为不管文件夹有没有file文件，都不报错，也不报成功。编译运行，ls -l 可以看到生成一个file文件。FIFO，也称为命名管道，它是一种文件类型。api原型：(man 3 mkfifo查看)
【hello Linux】进程间通信——命名管道
qq_52842680的博客
04-27 863
命令行的命名管道、命名管道的创建、 命名管道的使用
Linux进程间通信——命名管道
JayceSun的博客
05-10 901
目录mkfifo命名管道命名管道与匿名管道的区别命名管道实现进程间通信示例client.cserver.c如何让Makefile编译多个文件 mkfifo 现在先通过这段命令来创建一个FIFO文件 mkfifo fifo 接着我们会发现目录下出现了这个文件 开始的"p"代表"fifo"是一个管道文件，接下来我们创建两个进程，一个向fifo写数据，另一个从fifo读数据 命名管道 进程间的通信根本就是要让不同的进程看到同一份资源，而匿名管道利用的是子进程继承父进程资源的特性，让他们看到同一份资源。那么
【Linux学习】进程间通信——匿名管道 | 命名管道
weixin_63726869的博客
03-14 1722
介绍了进程间通信的相关概念，详细讲解了匿名管道和命名管道的工作原理和代码实现。还有详细介绍了进程池小项目。
Linux进程间通信——匿名管道|命名管道
m0_70289867的博客
12-15 1000
匿名管道 命名管道
Linux——命名管道
m0_72165281的博客
05-04 711
linux——命名管道
linux 命名管道 c语言 不同进程,C语言进程间通信（2）——命名管道
weixin_32431435的博客
05-02 170
C语言进程间通信(二)——命名管道FIFO也称命名管道，是一种文件类型，在文件系统中可见到。管道由于没有名字，所以只能限定在亲缘关系的进程之间的通信。而通过FIFO任意进程之间都能够进行通信了。FIFO的特点如下：命名管道可用于任何两个进程之间的通信，比管道灵活得多命名管道作为特殊文件存在文件系统中，当进程使用结束后仍存在文件系统，需要“手动”删除创建一个命名管道可以用mkfifo [管道名]，删...
linux 命名管道实例详解
01-10
linux进程间通信——命名管道  FIFO（命名管道）不同于匿名管道之处在于它提供⼀个路径名与之关联，以FIFO的⽂件形式存储于⽂件系统中。命名管道是⼀个设备⽂件，因此，即使进程与创建FIFO的进程不存在亲缘关系，...
Linux内核源代码情景分析 (上下册 高清非扫描 )
03-27
6.3 命名管道 6.4 信号 6.5 系统调用ptrace（）和进程跟踪 6.6 报文传递 6.7 共享内存 6.8 信号量 第7章基于socket的进程间通信 7.1系统调用socket() 7.2函数sys—socket()——创建插口 7.3函数sys—bind()——...
linux 内核源代码分析
07-26
6．3 命名管道 6．4 信号 6. 5 系统调用ptrace()和进程跟踪 6．6 报文传递 6．7 共享内存 6．8 信号量 第7章 基于socket的进程间通信 7．1 系统调用socket() 7．2 函数sys—socket()——创建插口 7．3 函数...
Linux中文件查找相关命令比较
最新发布
lurenyi168的专栏
06-16 183
Linux中与文件定位的命令有find、locate、whereis、which，type。
解决 Linux 和 Java 1.8 中上传中文名称图片报错问题
appearappear的博客
06-12 266
在 Linux 系统和 Java 1.8 中，当尝试上传含有中文名称的图片时，可能会遇到以下错误提示：为了解决这个问题，可以采取以下方法：在 Docker 的 中添加如下参数：Dockerfile使用以下命令启动 Java 程序，添加 参数：通过以上配置，确保了在启动 Java 程序时，使用了 UTF-8 编码，这样可以正确处理含有中文名称的文件，避免了报错问题的发生。3.5
Linux下Shell脚本基础知识
qq_28576837的博客
06-16 576
是由LINUX操作系统本身创建和维护的预定义变量。它们的标准约定是通常以大写字母进行定义。因此，每当看到以大写字母定义的变量时，很可能它们就是系统定义的变量。要了解系统中这些变量的列表，请在命令行终端上键入命令。
Linux基础命令
威桑的博客
06-11 956
常见基础Linux命令
Linux 命令大全
lly202406的博客
06-16 234
Linux是一个强大的操作系统，它通过命令行界面提供了丰富的功能和灵活性。了解和掌握各种Linux命令对于系统管理员和开发者来说至关重要。本文将为您提供一个全面的Linux命令大全，帮助您更好地理解和使用Linux系统。
Linux，shell ,gun基本概念和关系
ZMXdecode的博客
06-16 248
2、除了由内核控制硬件设备外，操作系统还需要工具来执行一些标准功能，比如控制文件（删除，复制，读取的权限，删除的权限）和程序（比如运行指定程序）。提供的是文件管理（这个文件管理不是我们的简单删除，复制什么的，具体可以查看操作系统的知识）、虚拟内存、设备I/O这些。3、Linux内核和GNU操作系统工具整合起来，就产生了一款完整的、功能丰富的免费操作系统所以通常将Linux内核和GNU工具的结合体称为Linux。，是一种特殊的交互式工具 ，用于提供用户与操作系统之间的交互接口。LiveCD测试发行版。
linux环境 system启动进程创建命名管道
05-26
在启动的进程中，可以使用 mkfifo 函数创建命名管道。 具体步骤如下： 1. 在终端中使用 mkdir 命令创建一个目录，例如： ``` mkdir myfifo ``` 2. 使用 mkfifo 命令创建一个命名管道，例如： ``` mkfifo ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值