基于消息队列的多进程服务器

最新推荐文章于 2024-05-29 22:51:32 发布
最新推荐文章于 2024-05-29 22:51:32 发布
阅读量888 收藏 5
点赞数
分类专栏： Linux学习 文章标签： Linux进程间通信 C
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/eeemmm/article/details/83376841
版权

目录

一、思路

参考：Linux进程间通信(IPC)编程实践（五）消息队列实现回射客户/服务器

1）server进程接收时, 指定msgtyp为0, 从队首不断接收消息；
2）server进程发送时, 将mtype指定为接收到的client进程的pid；
3）client进程发送的时候, mtype指定为自己进程的pid；
4）client进程接收时, 需要将msgtyp指定为自己进程的pid, 只接收消息类型为自己pid的消息。

问题：

但上述程序是存在死锁的风险的，当同时开了多个客户端，将队列写满了，此时服务器端想要写入就会阻塞，而因为客户端一旦发送了数据就阻塞等待服务器端回射类型为pid的消息，即队列的消息不会减少，此时就会形成死锁，互相等待。非阻塞方式发送也不行，因为队列已满，会发生EAGAIN错误。

改进：

某个客户端先创建一个私有消息队列，然后将私有消息队列标识符和具体数据通过共享的队列发送给Server，服务器fork 出一个子进程，此时根据私有队列标识符就可以将数据回射到这个队列，这个客户端就可以从私有队列读取到回射的数据。

二、实现

1. 原始代码

server.c

/*  Server  */
#include <stdlib.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <sys/types.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>

#define ERR_EXIT(m) \
    do { \
        perror(m); \
        exit(EXIT_FAILURE); \
    } while(0)

#define MSGMAX 8192
struct msgbuf
{
    long mtype; 
    char mtext[MSGMAX];
};


void echo_ser(int msgid)
{
    struct msgbuf msg;
    memset(&msg, 0, sizeof(msg));
    int nrcv ;
    while (1)
    {
        if ((nrcv = msgrcv(msgid, &msg, sizeof(msg.mtext), 1, 0)) < 0); //指定接受优先级为1的（msgtyp） 
        int pid = *((int *)msg.mtext);
        fputs(msg.mtext + 4, stdout);
        msg.mtype = pid;
        msgsnd(msgid, &msg, nrcv, 0);
        memset(&msg, 0, sizeof(msg));

    }
}

int main(int argc, char *argv[])
{
    int msgid;
    msgid = msgget(1234, IPC_CREAT | 0666); //创建一个消息队列 
    if (msgid == -1)
        ERR_EXIT("msgget");

    echo_ser(msgid);


    return 0;
}

//--------------------- 
//作者：NK_test 
//来源：CSDN 
//原文：https://blog.csdn.net/NK_test/article/details/49866113 
//版权声明：本文为博主原创文章，转载请附上博文链接！

client.c

#include <stdio.h>
#include <stdlib.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <sys/types.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>

#define ERR_EXIT(m) \
    do { \
        perror(m); \
        exit(EXIT_FAILURE); \
    } while(0)

#define MSGMAX 8192

struct msgbuf
{
    long mtype;
    char mtext[MSGMAX];
};

void echo_cli(int msgid)
{
    int nrcv;
    int pid = getpid();
    struct msgbuf msg;
    memset(&msg, 0, sizeof(msg));
    msg.mtype = 1;
    *((int *)msg.mtext) = pid;
    while (fgets(msg.mtext + 4, MSGMAX, stdin) != NULL) //客户端输入信息 
    {

        if (msgsnd(msgid, &msg, MSGMAX, IPC_NOWAIT) < 0)
            ERR_EXIT("msgsnd");

        memset(msg.mtext + 4, 0, MSGMAX - 4);
        if ((nrcv = msgrcv(msgid, &msg, MSGMAX, pid, 0)) < 0)
            ERR_EXIT("msgsnd");
        fputs(msg.mtext + 4, stdout);
        memset(msg.mtext + 4, 0, MSGMAX - 4);

    }
}

int main(int argc, char *argv[])
{

    int msgid;
    msgid = msgget(1234, 0); //打开名为1234的消息队列 
    if (msgid == -1)
        ERR_EXIT("msgget");

    echo_cli(msgid);

    return 0;
}
//--------------------- 
//作者：NK_test 
//来源：CSDN 
//原文：https://blog.csdn.net/NK_test/article/details/49866113 
//版权声明：本文为博主原创文章，转载请附上博文链接！

2. 修改

2.1 思路

在这里插入图片描述

2.2 代码

server.c

/*  Server  */
#include <stdlib.h>
#include <stdio.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <sys/types.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <signal.h>

#define MAX 512

#define ERR_EXIT(m)         \
    do                      \
    {                       \
        perror(m);          \
        exit(EXIT_FAILURE); \
    } while (0)

struct msgbuf
{
    long mtype;
    char mtext[1];
};

void echo_ser(int pmsgid)
{
    int nrcv;
    struct msgbuf *pmsg_snd;
    struct msgbuf *pmsg_rcv;
    char text[MAX];
    
    while (1)
    {
        pmsg_rcv = (struct msgbuf *)malloc(sizeof(struct msgbuf) + MAX);
        nrcv = msgrcv(pmsgid, pmsg_rcv, MAX, 0, 0);
        if (nrcv == -1)
        {
            ERR_EXIT("pmsg_rcv error");
        }

        printf("Client: %s", pmsg_rcv->mtext);
        free(pmsg_rcv);

        strcpy(text,"Received. ");
        pmsg_snd = (struct msgbuf *)malloc(sizeof(struct msgbuf) + sizeof(text));
        pmsg_snd->mtype = 2;
        strcpy(pmsg_snd->mtext, text);
        nrcv = msgsnd(pmsgid, pmsg_snd, sizeof(text), IPC_NOWAIT);
        if (nrcv == -1)
            ERR_EXIT("pmsg_snd error");

        free(pmsg_snd);
    }
}

int main(int argc, char *argv[])
{
    struct msgbuf *msg;
    int nrcv;
    int pid;
    int pmsgid;

    //创建一个消息队列
    int msgid;
    msgid = msgget(1234, IPC_CREAT | 0666);
    printf("%d\n",msgid);
    if (msgid == -1)
        ERR_EXIT("msgget error");


    //忽略子进程退出的细节
    signal(SIGCHLD, SIG_IGN);
    while (1) //接收到新的连接消息
    {
        msg = (struct msgbuf *)malloc(sizeof(struct msgbuf) + MAX);
        //接受连接, mtype=1
        nrcv = msgrcv(msgid, msg, MAX, 1, 0);
        if (nrcv == -1){
            ERR_EXIT("msgrcv error");
        }
        pmsgid = *((int *)msg->mtext);
        printf("\npmsgid =  %d \n", pmsgid);
        pid = fork();
        if (pid == 0) //子进程
        {
            echo_ser(pmsgid);
        }
    }

    return 0;
}

client.c

#include <stdio.h>
#include <stdlib.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <sys/types.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>

#define MAX 512

#define ERR_EXIT(m)         \
    do                      \
    {                       \
        perror(m);          \
        exit(EXIT_FAILURE); \
    } while (0)

struct msgbuf
{
    long mtype;
    char mtext[1];
};

void echo_cli(int pmsgid)
{
    int nrcv;
    struct msgbuf *pmsg_snd;
    struct msgbuf *pmsg_rcv;
    char text[MAX];
    printf("Enter some text: ");
    while (fgets(text, MAX, stdin) != NULL) //客户端输入信息
    {
        pmsg_snd = (struct msgbuf *)malloc(sizeof(struct msgbuf) + sizeof(text));
        pmsg_snd->mtype = 2;
        strcpy(pmsg_snd->mtext, text);
        nrcv = msgsnd(pmsgid, pmsg_snd, sizeof(text), IPC_NOWAIT);
        if (nrcv == -1)
            ERR_EXIT("pmsg_snd error");

        free(pmsg_snd);

        pmsg_rcv = (struct msgbuf *)malloc(sizeof(struct msgbuf) + MAX);
        nrcv = msgrcv(pmsgid, pmsg_rcv, MAX, 0, 0);

        if (nrcv == -1)
        {
            ERR_EXIT("pmsg_rcv error");
        }
        printf("Server: %s\nEnter some text:", pmsg_rcv->mtext);
        free(pmsg_rcv);
    }
}

int main(int argc, char *argv[])
{
    int pmsgid;
    int msgid;
    int ret;
    struct msgbuf *msg;

    //创建一个私有消息队列
    pmsgid = msgget(IPC_PRIVATE, IPC_CREAT | 0666);
    if (pmsgid == -1)
        ERR_EXIT("msgget error");

    printf("message %d queue created!\n", pmsgid);

    //将私有消息队列标识符和具体数据通过共享的队列发送给Server

    //打开名为1234的消息队列
    msgid = msgget(1234, 0);
    if (msgid == -1)
        ERR_EXIT("msgget error");

    msg = (struct msgbuf *)malloc(sizeof(struct msgbuf) + sizeof(pmsgid));
    msg->mtype = 1;
    *((int *)msg->mtext) = pmsgid;
    printf("%d\n", *((int *)msg->mtext));

    //发送消息
    ret = msgsnd(msgid, msg, sizeof(pmsgid), IPC_NOWAIT);
    if (ret == -1)
    {
        ERR_EXIT("msgsnd error");
    }
    free(msg); //发送完毕，释放内存
    printf("msg send.\n");

    echo_cli(pmsgid);

    ret = msgctl(pmsgid, IPC_RMID, NULL);
    if (ret == -1)
    {
        ERR_EXIT("del error");
    }
    return 0;
}
AWei_i_i
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Windows Redis 多服务器集群部署
tantu666的博客
01-03 1157
为了客户端调用安全，我启用了密码，执行将每台服务器每个端口文件夹中的redis.windows.conf文件中的requirepass启用并设置对应的密码即可，如下，修改好后，别忘了重新对应的服务。如果希望快速自动启动redis，那么我们可以将其设置为windows服务，并设置为自动启动即可，只需在对应的文件夹下cmd，输入如下命令即可，注意，每台服务器，两个文件夹都需要注册。将其中一台服务器的主节点关闭，然后再cluster nodes监测一下，发现主节点已经挂掉，原来的从节点变成了主节点。
多进程编程（三）：消息队列
努力搬砖的打工人
06-25 414
进程间通信：消息队列
C++进程间通信 消息队列
最新发布
Warren++的博客
05-29 833
C++进程间通信 消息队列
C++多线程和消息队列用法
三言两语
02-14 4331
进程是没有活力的，它只是一个静态的概念。为了让进程完成一些工作，进程必须至少占有一个线程，所以线程是描述进程内的执行，正是线程负责执行包含在进程的地址空间中的代码。实际上，单个进程可以包含几个线程， 它们可以同时执行进程的地址空间中的代码。为了做到这一点，每个线程有自己的一组CPU寄存器和堆栈。       线程是进程内部的一个执行单元。系统创建好进程后，实际上就启动执行了该进程的主执行线程，主
消息队列的介绍及配置
qq_36306519的博客
06-15 3008
消息队列的介绍及配置
消息队列及常见消息队列介绍
2301_78008478的博客
06-19 1036
消息队列（Message Queue），是分布式系统中重要的组件，其通用的使用场景可以简单地描述为：当不需要立即获得结果，但是并发量又需要进行控制的时候，差不多就是需要使用消息队列的时候。消息队列主要解决了应用耦合、异步处理、流量削锋等问题。当前使用较多的消息队列有RabbitMQ、RocketMQ、ActiveMQ、Kafka、ZeroMQ、MetaMq等，而部分数据库如Redis、Mysql以及phxsql也可实现消息队列的功能。
workerman 消息队列，基于Linux sysv 队列实现
06-03
5. **负载均衡**：多进程可以同时从队列中获取任务，实现负载均衡。 五、Workerman-queue-master项目 `workerman-queue-master`可能是Workerman消息队列的源代码仓库，包含了实现、配置示例和使用说明。在该项目中...
Linux下用C语言基于消息队列编写多人聊天室
01-07
服务器实现各用户之间聊天的消息转发，在用户注册或者登录时对各用户进行消息提醒，客户端从服务端获得相应进程信息，并用消息队列通过服务端与其他客户端进行通信。 客户端进程运行时，运行命令后需要添加名字表示...
亲测可用基于Linux消息队列的简易聊天室(C语言).zip
05-07
亲测可用的基于Linux消息队列的简易聊天室(C语言)(附源代码)采用客户-服务器结构，其中服务器实现各个用户的登录并存储相关信息，客户端通过服务器端获取当前登录用户信息，然后各客户进程通过消息队列实现双向通信...
Redis延时消息队列基于swoole实现的多进程消费端
08-07
标题中的“Redis延时消息队列基于swoole实现的多进程消费端”是指使用Redis作为消息队列，结合Swoole的多进程特性来构建一个高效、可扩展的延迟消息处理系统。在这个系统中，Redis作为一个可靠的键值存储，用于暂存...
基于spring 消息队列
12-04
1. **消息队列**：消息队列作为进程间通信的一种方式，可以解耦生产者和消费者，提高系统的响应速度和可扩展性。它允许生产者将消息发送到队列，而消费者可以在合适的时间异步处理这些消息，降低了系统之间的依赖性...
游戏服务器的消息队列,游戏服务器的消息队列
weixin_39551103的博客
08-07 512
游戏服务器的消息队列 内容精选换一换华为云分布式消息服务帮助中心，为用户提供产品介绍、用户指南、API参考、最佳实践、常见问题、视频帮助等技术文档，帮助您快速上手使用分布式消息服务。本指南以Kafka队列(非专享版)为例，指导您快速上手分布式消息服务游戏服务器的消息队列 相关内容分布式消息服务(Distributed Message Service，简称DMS)是一项基于高可用分布式集群技术的消息...
UNIX/LINUX编程学习之进程通信--消息队列
08-14 761
转自： http://shihaiyang.iteye.com/blog/483154 一、消息队列的基本概念      消息队列是一个存放在内核中的消息链表，每个消息队列由消息队列标识符标识。与管道不同的是消息队列存放在内核中，只有在内核重启（即操作系统重启）或者显示
消息队列——RabbitMq
weixin_45080272的博客
05-28 4286
一、消息队列的使用场景 一、消息队列的使用场景) 一、消息队列的使用场景 异步处理 应用解耦 流量削锋 消息通讯 【1】异步处理：场景说明：用户注册后，需要发注册邮件和注册短信。 引入消息队列后架构如下：用户的响应时间=注册信息写入数据库的时间，例如50毫秒。发注册邮箱、发注册短信写入消息队列后，直接返回客户端，因写入消息队列的速度很快，基本可以忽略，因此用户的响应时间可能是50毫秒。 按照传统的做法： ①、串行方式，将注册信息写入数据库成功后，发注册邮件，再发送注册短信，以上三个成功后，返回客户端。可
任务2：消息队列通信实现一个简单的客户/服务器应用，多个客户进程task42c可并发地向服务器进程发送消息，服务器task42s向每个客户发送消息接收回执。
weixin_45950398的博客
05-13 1851
任务2：编写消息队列通信程序task42s.c和task42c.c，利用消息队列通信实现一个简单的客户/服务器应用，多个客户进程task42c可并发地向服务器进程发送消息，服务器task42s向每个客户发送消息接收回执。比如进程PID为1234的客户端发送的消息为”hello from Process 1234”，服务器收到该消息后发回消息为“receipt of hello from <您的姓名xxx>’s server to Process 1234”TOC](这里写自定义目录标题) 消息队
Linux进程间通信编程
ywd171的博客
11-24 3711
任务1： 要求：编写程序task71.c实现进程的管道通信。父进程创建两个子进程，父子进程通过管道来传送数据。两个子进程P1和P2分别向管道各写一句话： Child P1 is sending My name <您的姓名XXX>! Child P2 is sending the current time <当前系统时间,包括年月日时分秒>! 父进程从管道中读出两个来自子进程的信息并显示。 提示：获取系统时间的函数是”time_t time(time_t *t);”，将t..
为什么需要使用消息队列
q89563848的博客
04-13 1633
MQ简介 消息队列（MQ）是一种应用程序对应用程序的通信方法，应用程序通过队列进行通信，而不是通过直接调用彼此来通信，队列的使用除去了接收和发送应用程序同时执行的要求。是进行通信的中间件产品。（换言之：MQ负责两个系统之间传递消息，这两个系统可以是异构的，处于不同硬件、不同操作系统、用不同语言编写，只需要简单的调用几个MQ的API，就可以互相通讯，你不必考虑底层系统和网络的复杂性。MQ能够应付多种...
常见的消息队列服务器,消息队列的4个常见应用场景
weixin_36478447的博客
08-13 1233
消息队列的4个常见应用场景分类：云服务资讯编辑：互联网观察浏览量：1932020-12-25 14:07:16几十年前，消息队列开始兴起，它用于连接大型机和服务器应用程序，并逐渐在企业的服务总线与事件总线设计模式、应用间的路由和数据迁移中发挥至关重要的作用。2020年处于移动互联网的下半场，各种技术层出不穷，虽然数据也在爆发式增长，但是高并发、高吞吐已经不再是首要的痛点，稳定、可靠才是王道。本文作...
学习笔记 | 操作系统 | 进程通信
大虎牙的博客
04-02 199
第6章 进程通信 6.1 为什么要通信？ 父进程在创建子进程后，通常需要监督子进程的状态，以便于子进程没有完成给定的任务时，可以再创建一个子进程来继续。这就需要父子进程间通信。 进程之间的交互称为进程间通信（Inter-Process Communication，IPC）。 6.2 进程对白：管道、记名管道、套接字 进程对白就是一个进程发出某种数据信息，另外一方接受数据信息，而这些数据信息通...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

AWei_i_i

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值