进程间通信：fifo实现本地多人聊天程序

已于 2023-02-13 12:26:56 修改
阅读量471 收藏 4
点赞数
分类专栏： Linux 文章标签： linux c语言 Powered by 金山文档
于 2023-02-13 03:28:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/d704791892/article/details/129002372
版权

知识点

作用:

创建一个有名管道，解决无血缘关系的进程间通信。

shell脚本创建一个fifo示例
C函数
#include <sys/tpyes.h>
#include <sys/stat.h>

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

  • 当只写打开fifo管道时，如果fifo读端没有打开，则写打开会阻塞。

  • fifo内核实现时可以支持双向通信（pipe单向通信，因为父子进程共享同一个file结构体）。

  • fifo可以一个读端，多个写端，也可以多个读端，一个写端。

通信示意图

程序分析

程序功能示意图
server进程：

  • mkfifo函数创建一条公共fifo，用open函数以O_RDONLY | O_NONBLOCK模式打开。循环用read函数读取客户端写给服务端的数据并进行处理。

  • 用fcntl函数设置STDIN_FILENO（接收键盘输入）为非阻塞（O_NONBLOCK），因为需要接收输入exit命令进行关闭服务器等等。循环用read函数接收键盘的输入。

  • 当客户端进行登录连接server时，用mkfifo函数为客户端创建一条私有fifo，用write函数写数据给客户端告诉客户端连接成功，每次通信完，需要关闭私有fifo的文件描述符。

client进程：

  • open函数以O_WRONLY模式打开公共fifo，open函数以O_RDONLY | O_NONBLOCK模式打开私有fifo，循环用read函数读取服务端写给客户端的数据并进行处理。

  • 用fcntl函数设置STDIN_FILENO（接收键盘输入）为非阻塞（O_NONBLOCK），因为需要从私有fifo读服务端写给客户端的数据，同时客户端也接收键盘的输入，进行聊天，同时也需要将屏幕输出等等。循环用read函数接收键盘的输入。

server_fifo.c

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>
#include <errno.h>

#define SERVER_FIFO_FILE "server_fifo_file"
#define BUF_SIZE 1024
#define CHAT_HEAD "send "
#define CHAT_HEAD_LEN strlen(CHAT_HEAD)

#define MSG_BEGIN 0
#define MSG_C2S_LOGIN 1
#define MSG_S2C_CONNECT 2
#define MSG_C2S_CHAT 3
#define MSG_S2C_CHAT 4
#define MSG_C2S_OFFLINE 5
#define MSG_S2C_OFFLINE 6
#define MSG_END 7

enum USER_STATUS
{   
    ONLINE = 1,
    OFFLINE = 2
};

struct MSG
{
        int id;
        char src[32];
        char dst[32];
        char data[512];
};

//用户数据链表
struct USER_NODE
{
    struct USER_NODE *pre;
    struct USER_NODE *next;
    unsigned short status; //0:不在线 1:在线
    char name[32]; //用户名    
};

struct USER_LIST
{
    int count;
    struct USER_NODE *head;
    struct USER_NODE *tail;
} g_user_list;

void insert_user(const char *name);
struct USER_NODE* find_user(const char *name);
void print_user_list();
void update_user_status(const char *name, int status);

void sys_err(const char *str, int exitno)
{
    perror(str);
    exit(exitno);
}

void exit_chat();
void user_offline(struct USER_NODE *puser);

void c2s_login(struct MSG *pmsg);
void c2s_offline(struct MSG *pmsg);
void c2s_chat(struct MSG *pmsg);

int main(int argc, char *argv[])
{
    if (access(SERVER_FIFO_FILE, F_OK) < 0) //文件不存在
    {
        if(mkfifo(SERVER_FIFO_FILE, 0777) < 0) //创建一条公共命名管道
            sys_err("mkfifo", 1); 

        printf("%s mkfifo success\n", SERVER_FIFO_FILE);
    }

    //设置标准输入为非阻塞
    int flags = fcntl(STDIN_FILENO, F_GETFL);
    flags |= O_NONBLOCK;
    if (fcntl(STDIN_FILENO, F_SETFL, flags) < 0)
        sys_err("fcntl", 1);

    int fd_r; //用于打开共享管道，读客户端发给服务端的数据
    int len = 0;
    struct MSG msg;
    char buf[BUF_SIZE];

    fd_r = open(SERVER_FIFO_FILE, O_RDONLY | O_NONBLOCK); //只读，用于接收客户端数据
    if (fd_r < 0)
        sys_err("open", 1);

    while(1)
    {
        //printf("loop begin\n");
        memset(&msg, 0, sizeof(struct MSG));
        memset(buf, 0, BUF_SIZE);

        //读共享管道数据
        len = read(fd_r, &msg, sizeof(struct MSG));
        if (len > 0)
        {    
            switch (msg.id)
            {
                case MSG_C2S_LOGIN:
                {
                    c2s_login(&msg);
                    break;
                }
                case MSG_C2S_CHAT:
                {
                    c2s_chat(&msg);
                    break;
                }
                case MSG_C2S_OFFLINE:
                {
                    c2s_offline(&msg);
                    break;
                }
                default:
                {
                    printf("not handle message id = %d\n", msg.id);
                    break;
                }
            }
        }
        else if (len == 0) //写端都关闭了
        {
            //printf("%s: write port close!\n", SERVER_FIFO_FILE);
            //sleep(1);
        }
        else
        {    
            if (errno != EAGAIN)
                sys_err("read", 1);
        }

        //读标准输入数据
        len = read(STDIN_FILENO, buf, BUF_SIZE); 
        if (len > 0)
        {
            if (strncmp(buf, "exit", 4) == 0)
                break;
        }
        else if (len == 0)
        {
        }
        else
        {
            if (errno != EAGAIN)
                sys_err("read", 1);
        }

        usleep(100000);
        //printf("loop end!\n");  
    }
    
    exit_chat();
    close(fd_r);
    unlink(SERVER_FIFO_FILE);

    return 0;
}

void c2s_login(struct MSG *pmsg)
{
    printf("c2s_login msg: id = %d, src = %s, dst = %s, data = %s\n", pmsg->id, pmsg->src, pmsg->dst, pmsg->data);

    if (access(pmsg->src, F_OK) < 0) //文件不存在
    {
        if (mkfifo(pmsg->src, 0777))    //为客户端创建一条私有命名管道
            sys_err("mkfifo", 1);
    }
    int fd_w = open(pmsg->src, O_WRONLY);
    if (fd_w < 0)
        sys_err("open", 1);

    struct USER_NODE *p = find_user(pmsg->src);
    if (p)
        update_user_status(pmsg->src, ONLINE);
    else
        insert_user(pmsg->src);

    struct MSG msg;
    msg.id = MSG_S2C_CONNECT;
    if (write(fd_w, &msg, sizeof(msg)) < 0)
        sys_err("write", 1);

    close(fd_w);        
}

void insert_user(const char *name)
{
    struct USER_NODE *p = find_user(name);
    if(p)
    {
        printf("insert fail, %s alread exist\n", name);
        return;
    }

    struct USER_NODE *user = (struct USER_NODE *)malloc(sizeof(struct USER_NODE));
    user->status = ONLINE;
    strcpy(user->name, name);

    if (g_user_list.count == 0)
    {
        user->pre = NULL;
        user->next = NULL;

        g_user_list.head = user;
        g_user_list.tail = user;
        g_user_list.count++;
    } 
    else
    {
        user->pre = g_user_list.tail;
        user->next = NULL;

        g_user_list.tail->next = user;
        g_user_list.tail = user;
        g_user_list.count++; 
    }
    printf("insert user success:%s\n", user->name);

    print_user_list();
}

struct USER_NODE* find_user(const char *name)
{
    struct USER_NODE *p = g_user_list.head;
    while(p)
    {
        if (strcmp(name, p->name) == 0)
            return p;

        p = p->next;        
    }    
    return NULL;
}

void print_user_list()
{
    struct USER_NODE *p = g_user_list.head;
    while(p)
    {
        printf("%s, status = %d\n", p->name, p->status);
        p = p->next;        
    }
}

void update_user_status(const char *name, int status)
{
    struct USER_NODE *p = find_user(name);
    if (!p)
    {
        printf("update fail:%s not exist", name);
        return;
    }

    p->status = status;    
}

void c2s_offline(struct MSG *pmsg)
{
    printf("c2s_offline msg: id = %d, src = %s, dst = %s, data = %s\n", pmsg->id, pmsg->src, pmsg->dst, pmsg->data);
    update_user_status(pmsg->src, OFFLINE);
}

void c2s_chat(struct MSG *pmsg)
{
    printf("c2s_chat msg: id = %d, src = %s, dst = %s, data = %s\n", pmsg->id, pmsg->src, pmsg->dst, pmsg->data);
    struct MSG msg;
    memset(&msg, 0, sizeof(struct MSG));
    msg.id = MSG_S2C_CHAT;

    struct USER_NODE *p = find_user(pmsg->dst);
    if (!p) //通知发送方，dst用户不存在
    {
        strcpy(msg.src, "not-exist");
        strcpy(msg.dst, pmsg->dst);
    }
    else if (p->status == OFFLINE) //通知发送方，dst用户不在线
    {
        strcpy(msg.src, "user-offline");
        strcpy(msg.dst, pmsg->dst);
    }
    else //将聊天信息转发给接收方
    {
        pmsg->id = MSG_S2C_CHAT;
    }
    

    if (pmsg->id != MSG_S2C_CHAT)
    {
        if (access(pmsg->src, F_OK) < 0) //文件不存在
        {
            if (mkfifo(pmsg->src, 0777) < 0)
                sys_err("mkfifo", 1);
        }

        int fd_w = open(pmsg->src, O_WRONLY);
        if (fd_w < 0)
            sys_err("open", 1);

        if (write(fd_w, &msg, sizeof(msg)) < 0)
            sys_err("write", 1);
            
        close(fd_w);
    }
    else //将聊天信息转发给接收方
    {
        if (access(pmsg->dst, F_OK) < 0) //文件不存在
        {
            if (mkfifo(pmsg->dst, 0777) < 0)
                sys_err("mkfifo", 1);
        }

        int fd_w = open(pmsg->dst, O_WRONLY);
        if (fd_w < 0)
            sys_err("open", 1);

        pmsg->id = MSG_S2C_CHAT;
        if (write(fd_w, pmsg, sizeof(*pmsg)) < 0)
            sys_err("write", 1);

        close(fd_w);
    }
}

void exit_chat()
{
    printf("开始退出聊天服务器，开始释放内存......\n");
    struct USER_NODE *p = g_user_list.head;
    struct USER_NODE *next = NULL;
    while(p)
    {
        if (p->status == ONLINE)
            user_offline(p);

        unlink(p->name);

        next = p->next;
        free(p);
        p = next;
    }

    printf("释放内存成功，退出聊天服务器成功......\n");
}

void user_offline(struct USER_NODE *puser)
{
    int fd_w = open(puser->name, O_WRONLY);
    if (fd_w < 0)
        sys_err("open", 1);

    struct MSG msg;
    msg.id = MSG_S2C_OFFLINE;
    if (write(fd_w, &msg, sizeof(msg)) < 0)
        sys_err("write", 1);
    
    close(fd_w);
}

client_fifo.c

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#include <errno.h>

#define SERVER_FIFO_FILE "server_fifo_file"
#define BUF_SIZE 1024
#define CHAT_HEAD "send "
#define CHAT_HEAD_LEN strlen(CHAT_HEAD)

#define MSG_BEGIN 0
#define MSG_C2S_LOGIN 1
#define MSG_S2C_CONNECT 2
#define MSG_C2S_CHAT 3
#define MSG_S2C_CHAT 4
#define MSG_C2S_OFFLINE 5
#define MSG_S2C_OFFLINE 6
#define MSG_END 7

struct MSG
{
        int id;
        char src[32];
        char dst[32];
        char data[512];
};
 
void sys_err(const char *str, int exitno)
{
    perror(str);
    exit(exitno);
}

void s2c_connect(struct MSG *pmsg);
void s2c_chat(struct MSG *pmsg);
void s2c_offline(struct MSG *pmsg);

int main(int argc, char * argv[])
{
    if (argc < 2)
    {
        printf("%s player name\n", argv[0]);
        exit(1);
    }

    if (access(SERVER_FIFO_FILE, F_OK) < 0)
    {
        printf("server offline\n");
        exit(1);
    }     

    //设置标准输入为非阻塞
    int flags = fcntl(STDIN_FILENO, F_GETFL);
    flags |= O_NONBLOCK;
    if (fcntl(STDIN_FILENO, F_SETFL, flags) < 0)
        sys_err("fcntl", 1);    

    int fd_w; //用于打开共享管道，写客户端发给服务端的数据
    int fd_r; //用于打开私有管道，读服务端发给客户端的数据 
    int len = 0;
    struct MSG msg;
    char buf[BUF_SIZE];

    fd_w = open(SERVER_FIFO_FILE, O_WRONLY);
    if (fd_w < 0)
        sys_err("open", 1);

    msg.id = MSG_C2S_LOGIN;
    strcpy(msg.src, argv[1]);
    len = write(fd_w, &msg, sizeof(msg));
    if (len < 0)
        sys_err("write", 1);
    sleep(1); //保证服务端收到以后建立私有管道

    fd_r = open(argv[1], O_RDONLY | O_NONBLOCK); //非阻塞读私有管道
    if (fd_r < 0)
        sys_err("open", 1);
    
    while(1)
    {
        //printf("loop begin\n");
        memset(&msg, 0, sizeof(struct MSG));        
        memset(buf, 0, BUF_SIZE);

        //读私有管道数据
        len = read(fd_r, &msg, sizeof(struct MSG));
        if (len > 0)
        {
            switch (msg.id)
            {
                case MSG_S2C_CONNECT:
                {
                    s2c_connect(&msg);
                    break;            
                }
                case MSG_S2C_CHAT:
                {
                    s2c_chat(&msg);
                    break;
                }
                case MSG_S2C_OFFLINE:
                {
                    s2c_offline(&msg);
                    break;
                }
                default:
                {
                    printf("not handle message id = %d\n", msg.id);
                    break;
                }
            }

            if (msg.id == MSG_S2C_OFFLINE) //服务器将用户主动踢下线
                break;
        }
        else if (len == 0)
        {
            //printf("%s: write port close!\n", argv[1]);
        }
        else
        {
            if (errno != EAGAIN)
                sys_err("read", 1);
        }
        
        //读标准输入数据
        len = read(STDIN_FILENO, buf, BUF_SIZE);
        if (len > 0)
        {
            memset(&msg, 0, sizeof(struct MSG));
            if (strncmp(buf, "exit", 4) == 0)
            {
                msg.id = MSG_C2S_OFFLINE;
                strcpy(msg.src, argv[1]);
                len = write(fd_w, &msg, sizeof(msg));
                if (len < 0)
                    sys_err("write", 1);
                
                //sleep(1); //保证服务端收到下线消息
                break;
            }
            else
            {
                char *p = strchr(buf, ':');
                int n = strspn(buf, CHAT_HEAD);
                if (p && n == CHAT_HEAD_LEN) //是发送聊天内容格式 send zhangsan: Hello
                {    
                    msg.id = MSG_C2S_CHAT;
                    strcpy(msg.src, argv[1]);
                    strncpy(msg.dst, buf+CHAT_HEAD_LEN, p-buf-CHAT_HEAD_LEN);
                    strcpy(msg.data, p+1); //去掉开头的:，所以+1
        
                    //printf("dst = %s\n", msg.dst);
                    //printf("data = %s\n", msg.data);
                    
                    len = write(fd_w, &msg, sizeof(msg));
                    if (len < 0)
                        sys_err("write", 1);
                }

            }
        }
        else if (len == 0)
        {
            printf("STDIN_FILENO\n");
        }
        else
        {
            if (errno != EAGAIN)
                sys_err("read", 1);
        }

        //printf("loop end\n");
        usleep(100000);
    }

    close(fd_w);
    close(fd_r);

    return 0;
}

void s2c_connect(struct MSG *pmsg)
{
    printf("connect success\n");
}

void s2c_chat(struct MSG *pmsg)
{
    //printf("s2c_chat:src = %s, dst = %s, data = %s\n", pmsg->src, pmsg->dst, pmsg->data);
    char buf[BUF_SIZE] = {0};
    if (strcmp(pmsg->src, "not-exist") == 0)
    {
        sprintf(buf, "%s 用户不存在\n", pmsg->dst);
    }
    else if (strcmp(pmsg->src, "user-offline") == 0)
    {
        sprintf(buf, "%s 用户不在线\n", pmsg->dst);
    }
    else
    {
        sprintf(buf, "recv %s: %s", pmsg->src, pmsg->data);
    }
    write(STDOUT_FILENO, buf, strlen(buf));     
}

void s2c_offline(struct MSG *pmsg)
{
}

运行效果截图

  • 启动服务器时

服务端

  • 启动客户端并以lisi用户登录时

客户端

服务端

  • 再启动多一个客户端并以jim用户登录，lisi跟jim聊天

客户端：lisi

服务端：将lisi发给jim的信息转发给jim

客户端：jim

微尘8
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
linux系统进程间通信共享内存方式实现及简单命令解释器实现.zip
04-30
里面是两个实验，一个共享内存方式的进程间通信，另一个是shell命令解释器。两个都是linux版本的。
Linux多进程间通信——共享内存实现聊天室程序
zhm1949的博客
05-22 1217
Linux多进程间通信——共享内存实现聊天室程序 上一讲我们用共享内存实现了进程间的简单通信，一个进程写，一个进程读，我们这次增加一点难度，创建两块共享内存，来实现一个简单的聊天室程序。 先自己动手做一下，再来看源码。 下面给出源码，一共有四个进程，两两实现通信，互相收发消息 shmmutexRW_Server.c代码如下： #include <semaphore.h> #include <stdio.h> #include <stdlib.h> #include &lt
进程间通信（二）
08-01 1000
传递更多的数据到目前为止我们所用的机制只是简单的在一个fread或是fwrite中发送或是接收全部的数据。有时我们也许以更小的尺寸发送数据，或是也许我们并不知道输出的大小。为了避免声明一个大的缓冲区，我们可以使用多个fread或是fwrite调用并分别处理这些数据。下面是一个程序，popen3.c，由一个管道中读取所有的数据。试验－－由一个管道读取大量的数据
IO：进程多线程实现简单的相互聊天的程序
jiangrang1的博客
07-26 235
进程多线程实现简单的相互聊天的程序
shell多线程之进程间通信（2）
weixin_30625691的博客
11-02 286
工作中往往遇到这种情况，有许多任务，依次执行比较浪费时间，由于任务之间有依赖关系，简单的并发执行又不行。 就如同下面这种情况，任务new和dvidUser是可以并发执行的，fact任务依赖于new任务，fact执行完之后last和stat才能执行； dvidUser执行完之后dvid和User两个任务才能执行。 针对这种情况，我考虑了操作系统中的信号量机制，通过借助linu...
Linux进程间通信：消息队列
01-20
消息队列允许一个或多个进程向它写入与读取消息. 　3.管道和命名管道都是通信数据都是先进先出的原则。 　4.消息队列可以实现消息的随机查询，消息不一定要以先进先出的次序读取，也可以按消息的类型读取.比FIFO更...
LINUX进程间通信：PIPE与FIFO - 山 人 - 博客园1
08-04
父进程可以往里写子进程可以从里读是用环形队列实现的数据从写端流入从读端流出这样就实现了进程间通信popen函数与pclose函数标准函数库提供了函数它创建一个管
FIFO.rar_进程间通信
09-14
客户进程-服务器通信，用于学习FIFO进程间通信
Linux 进程通信之FIFO的实现
09-14
主要介绍了Linux 进程通信之FIFO的实现，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
Python中的进程间通信
12-20
文章目录Python中的进程间通信1 进程间通信1.1 概念1.2进程间通信方法各种进程间通信1. 基于信号量（Semaphore）的IPC2 基于信号（Signal）的IPC3.基于管道（Pipe）的IPC4. 基于有名管道（fifo）的IPC5.基于消息队列...
进程间通信(三)——shell实现(dup2)
Scroll_C的博客
03-10 1226
无名管道(2)：shell管道的实现 小技巧：统计一个文件下有多少行代码？ wc -l 文件名 就能得到文件的行数 搭配使用 cat pipe.c | wc -l 小技巧：搜索文件里面的内容 grep "#include" 文件名 小技巧：查看命令在什么地方 whereis ls Shell中的管道通信 管道的作用 Shell中具有亲缘关系的进程之间传递消息 管道的本质是一个字节流 cat pipe.c | wc -l 将标准输出重定向到管道里面 在shell中运行命令.
进程间通信
qq_36553387的博客
06-02 1064
进程间通信 进程经常需要与其他进程通信。例如，在一个shell管道中，第一个进程的输出必须传送给第二个进程，这样沿着管道传递下去。因此在进程之间需要通信，必须要使用一种良好的数据结构以至于不能被中断。 关于进程间通信，这里有三个问题。 一个进程如何把信息传递给另一个。 确保两个或更多的进程在关键活动中不会出现交叉。 第三个问题是数据的先后顺序的问题，如果进程A产生数据并且进程B打印数据，则进程B打印数据之前需要先等A产生数据之后才能够进行打印。 有必要说明，这三个问题中的两个问题对于线程来说是同样适用的
操作系统：进程间通信
ShellDawn的博客
07-08 315
管道、消息队列、信号量+共享内存{\red{管道、消息队列、信号量+共享内存}}管道、消息队列、信号量+共享内存 管道：{\green{管道：}}管道： 分为无名管道，有名管道， 区别在于无名管道用于具有亲属关系进程之间的通信； 有名管道在无关进程间通信。 半双工，具有固定的写端和读端。 半双工，可以读和写，但不能同时读和写。 消息队列：{\green{消息队列：}}消息队列： 消息队列是操作...
Shell实现Unix进程间信息交换的几种方法（转）
专栏
11-05 1791
<br />文将介绍在SCO OpenServer5.0.5系统中使用shell语言来实现进程间信息交换的几种方法：　<br /><br /> 使用命名管道实现进程间信息交换　<br /><br /> 使用kill命令和trap语句实现进程间信息交换　<br /><br /> 使用点命令“.”实现进程间信息交换　<br /><br /> 使用export语句实现父进程对子进程的信息传递　<br /><br />一、使用命名管道<br />命名管道是一种先进先出（FIFO）的数据结构，它允许两个进程通
Linux进程间通信（下）
小小一只程序员的博客
08-10 236
本文介绍Linux进程间通信中消息队列、共享内存和信号量的使用。
进程间的通信
zsffzb的博客
10-29 518
一，进程间通信简介 由于每个进程都有自己独立的运行环境，因此进程与进程间是相对封闭的。如何让两个封闭的进程之间实现数据通信是进程编程的重点与难点。 Linux的内的进程通信机制基本来源于Unix的系统对Unix的发展做出巨大贡献的两大主力--AT＆T公司的贝尔实验室和加州大学伯克利分校 - 。在进程通信领域研究的侧重点不同。 贝尔实验室对Unix系统早期的进程间通信手段进行了改进与扩充，形成了System V IPC（进程间通信）。互相通信的进程被限定在单个计算机内。而伯克利分校则跳出...
linux shell多进程通信,Linux Shell实现多进程并发执行
weixin_36164462的博客
04-28 286
在bash中，使用后台任务来实现任务的“多进程化”。在不加控制的模式下，不管有多少任务，全部都后台执行。也就是说，在这种情况下，有多少任务就有多少“进程”在同时执行。我们就先实现第一种情况：在bash中，使用后台任务来实现任务的“多进程化”。在不加控制的模式下，不管有多少任务，全部都后台执行。也就是说，在这种情况下，有多少任务就有多少“进程”在同时执行。我们就先实现第一种情况：实例一：正常情况脚本...
linux shell多进程通信,linux shell控制并发进程数实践 · BG2BKK Site
weixin_35651191的博客
04-28 261
shell脚本多线程应用同事将新上线APP的一部分log交给我，让我统计下这些log中供出现了哪些deviceid采用awk就可以实现这部分匹配和统计功能，还是比较简单的挑战在于，这批log文件非常多非常大，单进程工作处理起来非常的慢。因此我想到了多进程方式。以往需要使用shell来实现多进程时，采用以下模板for seq; do{task}&done* 当任务较为简单，并发数不多时，这招...
【Linux】进程间通信（1）
weixin_42809675的博客
01-14 560
进程间通信1
shell命令来创建进程原理
最新发布
05-26
在 shell 中创建进程可以通过执行一些内置的命令或者外部命令来实现。其中，创建进程的原理是利用操作系统提供的系统调用接口。 操作系统提供了一个 fork 系统调用，它的作用是创建一个与当前进程完全相同的新进程，并在新进程中运行指定的程序。具体原理如下： 1. 当执行 fork 系统调用时，操作系统会为新进程分配一个新的进程控制块（PCB），并将父进程的 PCB 复制一份到新进程的 PCB 中。 2. 然后，操作系统将新进程的 PCB 加入到进程队列中，等待 CPU 调度运行。 3. 接着，新进程会从 fork 系统调用的返回值中获取一个进程 ID（PID），这个 PID 是唯一的，可以用来标识该进程。 4. 父进程和子进程之间除了进程 ID 不同以外，其它所有的资源和状态都是相同的。如果父进程和子进程需要通过管道或共享内存进行通信，则需要使用特定的系统调用。 5. 子进程可以使用 exec 系统调用来加载新的程序，然后替换自己的代码和数据。这样子进程就可以执行不同的任务了。 总的来说，shell 命令创建进程的本质是通过系统调用来创建一个新的进程，并为其分配资源和状态。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值