System V消息队列实现服务器

最新推荐文章于 2024-05-10 17:13:48 发布
最新推荐文章于 2024-05-10 17:13:48 发布
阅读量304 收藏
点赞数
分类专栏： Linux系统编程 文章标签： 服务器 应用
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_38044916/article/details/78500038
版权

每个应用一个队列

/*服务器程序*/
#include<stdio.h>
#include<stdlib.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<unistd.h>
#include<sys/msg.h>
#include<fcntl.h>
#include<limits.h>
#include<errno.h>
#include<string.h>
//#define SVMSG_MODE ()
#define MQ_KEY1 1231L
#define MQ_KEY2 2340L
#define MAXMESGDATA (PIPE_BUF - 2*sizeof(long))
//#define MESGHDRSIZE (sizeof(st))
struct mymesg
{
    long mesg_len;
    long mesg_type;
    char mesg_data[MAXMESGDATA];
};
#define MESGHDRSIZE (sizeof(struct mymesg) - MAXMESGDATA)

void server(int, int);
ssize_t mesg_send(int, struct mymesg*);
ssize_t mesg_recv(int, struct mymesg*);

int main(int argc, char **argv)
{
    int msqid;

    /*创建消息队列*/
    msqid = msgget(MQ_KEY1, 0666 | IPC_CREAT);
    server(msqid, msqid);/*读写都是一个队列*/
    exit(0);
}
/*发送消息*/
ssize_t mesg_send(int id, struct mymesg *mptr)
{
    return msgsnd(id, &(mptr->mesg_type), mptr->mesg_len, 0);
}
/*接受消息*/
ssize_t mesg_recv(int id, struct mymesg *mptr)
{
    ssize_t n;

    n = msgrcv(id, &(mptr->mesg_type), MAXMESGDATA, mptr->mesg_type, 0);
    return n;
}
void server(int readfd, int writefd)
{
    struct mymesg mesg;
    size_t len;
    ssize_t n;
    char *ptr;
    unsigned long pid;
    FILE *fp;

    while(1)/*服务器一直在运行*/
    {
        mesg.mesg_type = 1;/*表示从客户端到服务器的数据*/
        if((n = mesg_recv(readfd, &mesg)) == 0)/*读取路径名和pid*/
            continue;
        printf("%s\n", mesg.mesg_data);
        if((ptr = strchr(mesg.mesg_data, ' ')) == NULL)
            continue;
        mesg.mesg_data[n] = '\0';
        *ptr++ = 0;/*ptr现在指向路径名*/
        //len = strlen(ptr);
        //ptr[len] = '\0';
        pid = atol(mesg.mesg_data);/*该函数以空格结束*/

        mesg.mesg_type = pid;/*表示从服务器发送到客户端的数据*/
        if((fp = fopen(ptr, "r")) == NULL)
        {
            printf("fopen failed\n");
            /*error: must tell client*/
        //  mesg.mesg_type = pid;
            snprintf(mesg.mesg_data+n, sizeof(mesg.mesg_data)-n, ":can't open %s\n", strerror(errno));
            mesg.mesg_len = strlen(mesg.mesg_data);
            mesg_send(writefd, &mesg);

        }
        else
        {
            while(fgets(mesg.mesg_data, MAXMESGDATA, fp) != NULL)/*从文件中读取数据*/
            {
                 mesg.mesg_len = strlen(mesg.mesg_data);
                 mesg_send(writefd, &mesg);
            }
            fclose(fp);
        }
    }
    /*send a 0-length message to signify the end*/
    mesg.mesg_len = 0;
    mesg_send(writefd, &mesg);
}
/*客户端程序*/
#include<stdio.h>
#include<stdlib.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<unistd.h>
#include<sys/msg.h>
#include<fcntl.h>
#include<limits.h>
#include<errno.h>
#include<string.h>
//#define SVMSG_MODE ()
#define MQ_KEY1 1231L
#define MQ_KEY2 2340L
#define MAXMESGDATA (PIPE_BUF - 2*sizeof(long))
//#define MESGHDRSIZE (sizeof(st))
struct mymesg
{
    long mesg_len;
    long mesg_type;
    char mesg_data[MAXMESGDATA];
};
#define MESGHDRSIZE (sizeof(struct mymesg) - MAXMESGDATA)

void client(int, int);
ssize_t mesg_send(int, struct mymesg*);
ssize_t mesg_recv(int, struct mymesg*);

int main(int argc, char **argv)
{
    int msqid;

    /*打开消息队列*/
    msqid = msgget(MQ_KEY1, 0);
    client(msqid, msqid);/*读写都是一个队列*/
    exit(0);
}
/*发送消息*/
ssize_t mesg_send(int id, struct mymesg *mptr)
{
    return msgsnd(id, &(mptr->mesg_type), mptr->mesg_len, 0);
}
/*接受消息*/
ssize_t mesg_recv(int id, struct mymesg *mptr)
{
    ssize_t n;

    n = msgrcv(id, &(mptr->mesg_type), MAXMESGDATA, mptr->mesg_type, 0);
    return n;
}
void client(int readfd, int writefd)
{
    struct mymesg mesg;
    pid_t pid;
    size_t len;
    ssize_t n;

    pid = getpid();
    snprintf(mesg.mesg_data, MAXMESGDATA, "%ld ", (long)pid);
    len = strlen(mesg.mesg_data);
    /*读取路径*/
    fgets(mesg.mesg_data+len, sizeof(mesg.mesg_data)-len, stdin);
    printf("%s\n", mesg.mesg_data);
    len = strlen(mesg.mesg_data);
    if(mesg.mesg_data[len-1] == '\n')
        len--;
    mesg.mesg_len = len;
    mesg.mesg_type = 1;/*表示从客户端发往服务器的数据*/
    /*向服务器发送请求*/
    mesg_send(writefd, &mesg);

    mesg.mesg_type = (long)pid;
    while((n = mesg_recv(readfd, &mesg)) >0)
        write(STDOUT_FILENO, mesg.mesg_data, n);
}

每个客户一个队列

/*************************************************************************
    > File Name: client.c
    > Author: ndj
    > Mail: ndj_ydd@163.com 
    > Created Time: Fri 10 Nov 2017 09:54:16 AM CST
 ************************************************************************/
/*服务器程序*/
#include<stdio.h>
#include<stdlib.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<unistd.h>
#include<sys/msg.h>
#include<string.h>
#include<errno.h>
#include<limits.h>
#include<signal.h>
#define MAXMESGDATA (PIPE_BUF - 2*sizeof(long))
#define SERVER_KEY 1234L/*服务器消息队列，众所周知的键*/
struct mymesg
{
    long mesg_len;
    long mesg_type;
    char mesg_data[MAXMESGDATA];
};
#define MESGHDRSIZE (sizeof(struct mymesg) - MAXMESGDATA)

ssize_t mesg_send(int, struct mymesg*);/*发送消息*/
ssize_t mesg_rcv(int, struct mymesg*); /*接受消息*/
void client(int, int);
void sig_chld(int);

int main(int argc, char **argv)
{
    int readid, writeid;/*消息队列描述符*/
    struct mymesg mesg;
    size_t len;
    ssize_t n;
    pid_t pid;
    char *ptr;
    FILE *fp;

    signal(SIGCHLD, sig_chld);/*注册信号处理函数*/
    /*创建众所周知的消息队列*/
    readid = msgget(SERVER_KEY, IPC_CREAT | IPC_EXCL | 0666);

    while(1)
    {
        if((n = mesg_rcv(readid, &mesg)) == 0)/*父进程在这里接受消息*/
            continue;

        if((pid = fork()) < 0)
        {
            fprintf(stderr, "fork failed\n");
            exit(EXIT_FAILURE);
        }
        else if(pid == 0)/*子进程，处理消息*/
        {
            mesg.mesg_data[n] = '\0';
            if((ptr = strchr(mesg.mesg_data, ' ')) == NULL) 
                exit(EXIT_FAILURE);/*退出子进程*/
            *ptr++ = 0;/*ptr指向pathname*/
            writeid = atol(mesg.mesg_data);/*客户端创建的消息队列，描述符*/
            mesg.mesg_type = 1;/*给type赋值*/

            /*打开文件*/
            if((fp = fopen(ptr, "r")) == NULL)
            {
                /*error: must tell client*/
                snprintf(mesg.mesg_data+n, MAXMESGDATA-n, ":can't open %s\n", strerror(errno));
                mesg.mesg_len = strlen(mesg.mesg_data);
                mesg_send(writeid, &mesg);
            }
            /*从文件中读取数据*/
            else
            {
                while(fgets(mesg.mesg_data, MAXMESGDATA, fp) != NULL)
                {
                    mesg.mesg_len = strlen(mesg.mesg_data);
                    mesg_send(writeid, &mesg);
                }
                fclose(fp);
            }
            mesg.mesg_len = 0;
            mesg_send(writeid, &mesg);
            exit(EXIT_SUCCESS);/*子进程退出*/
        }

    }
}

ssize_t mesg_send(int fd, struct mymesg *mesg)
{
    return msgsnd(fd, &(mesg->mesg_type), mesg->mesg_len, 0);
}

ssize_t mesg_rcv(int fd, struct mymesg *mesg)
{
    ssize_t n;

    n = msgrcv(fd, &(mesg->mesg_type), MAXMESGDATA,mesg->mesg_type, 0);
    mesg->mesg_len = n;
    return n;
}

/*信号处理函数:避免僵尸进程*/
void sig_chld(int signo)
{
    pid_t pid;
    int stat;
    while((pid = waitpid(-1, &stat,WNOHANG)) > 0);
    return;
}

/*************************************************************************
    > File Name: client.c
    > Author: ndj
    > Mail: ndj_ydd@163.com 
    > Created Time: Fri 10 Nov 2017 09:54:16 AM CST
 ************************************************************************/
/*客户端程序*/
#include<stdio.h>
#include<stdlib.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<unistd.h>
#include<sys/msg.h>
#include<string.h>
#include<errno.h>
#include<limits.h>
#define MAXMESGDATA (PIPE_BUF - 2*sizeof(long))
#define SERVER_KEY 1234L/*服务器消息队列，众所周知的键*/
struct mymesg
{
    long mesg_len;
    long mesg_type;
    char mesg_data[MAXMESGDATA];
};
#define MESGHDRSIZE (sizeof(struct mymesg) - MAXMESGDATA)

ssize_t mesg_send(int, struct mymesg*);/*发送消息*/
ssize_t mesg_rcv(int, struct mymesg*); /*接受消息*/
void client(int, int);

int main(int argc, char **argv)
{
    int readid, writeid;/*消息队列描述符*/

    writeid = msgget(SERVER_KEY, 0);/*引用服务器已经存在的消息队列*/
    readid = msgget(IPC_PRIVATE, IPC_CREAT | IPC_EXCL | 0666);/*创建客户端自己的消息队列用于接受消息*/

    client(readid, writeid);
    exit(0);
}

ssize_t mesg_send(int fd, struct mymesg *mesg)
{
    return msgsnd(fd, &(mesg->mesg_type), mesg->mesg_len, 0);
}

ssize_t mesg_rcv(int fd, struct mymesg *mesg)
{
    ssize_t n;

    n = msgrcv(fd, &(mesg->mesg_type), MAXMESGDATA,mesg->mesg_type, 0);
    mesg->mesg_len = n;
    return n;
}

void client(int readfd, int writefd)
{
    struct mymesg mesg;
    ssize_t n;
    size_t len;

    mesg.mesg_type = 1;
    snprintf(mesg.mesg_data, MAXMESGDATA, "%d ", readfd);
    len = strlen(mesg.mesg_data);
    fgets(mesg.mesg_data+len, MAXMESGDATA-n, stdin);
    len = strlen(mesg.mesg_data);
    if(mesg.mesg_data[len-1] == '\n')
        len--;
    mesg.mesg_len = len;
    mesg_send(writefd, &mesg);/*发送 msqid+pathname*/
    mesg.mesg_type = 0;
    while((n = mesg_rcv(readfd, &mesg)) > 0)
        write(STDOUT_FILENO, mesg.mesg_data, n);
}
NDJForever
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
一文详解七大主流消息队列（MQ）：特性、应用场景与对比分析
java专栏
04-16 2767
总结来说，选择哪种MQ库取决于您的具体需求，如消息吞吐量、延迟要求、消息可靠性、顺序保证、事务支持、云平台集成、跨平台兼容性、易用性、运维成本等因素。由于MQ（Message Queue，消息队列）种类繁多，且每种MQ都有其独特的特性和应用场景，因此这里将为您提供对几种主流MQ库的详细讲解，从不同角度对比和分析它们的特点。：金融交易、订单处理、支付结算、数据同步、日志采集等对消息顺序和事务性有严格要求的场景。：适用于微服务间的异步通信、任务队列、事件驱动架构、跨系统的数据同步等。
浅谈如何自我实现一个消息队列服务器(1)——需求分析
m0_63191002的博客
03-13 1266
消息队列是将阻塞队列这样的数据结构，单独提取成一个程序，独立部署在一组服务器上。但阻塞队列是在一个进程内部进行的，而消息队列是在进程与进程(服务与服务)之间进行的。如果有同学不知道什么是阻塞队列，点击我前面写的博客多线程的典型例子——阻塞队列进行查漏补缺。1、需要实现 生产者、消费者、broker server 三个部分。2、针对生产者（producer client）和消费者（consumer client）来说，主要编写的是 客户端（client）和服务器（server） 进行网络通信的部分。
C# Microsoft消息队列服务器的使用 MSMQ
qq_34677276的博客
08-02 667
C# Microsoft消息队列服务器的使用 MSMQ
什么是消息队列以及它的三个核心概念
m0_53396342的博客
04-18 802
软件测试面试题：什么是消息队列以及它的三个核心概念
消息队列的介绍及配置
qq_36306519的博客
06-15 3057
消息队列的介绍及配置
workerman 消息队列，基于Linux sysv 队列实现
06-03
在这个特定的场景中，我们讨论的是Workerman如何实现消息队列，并且是基于Linux的System V（sysv）消息队列进行的实现。消息队列是一种在进程间通信（IPC）中存储和传递消息的机制，它允许进程间异步地发送和接收...
基于systemV的消息队列的多进程间CS通讯实现
05-19
标题中的“基于systemV的消息队列的多进程间CS通讯实现”是指使用System V消息队列作为基础，构建了一种客户机/服务器（Client/Server）模式的多进程通信机制。System V消息队列是UNIX/Linux系统中的一种进程间通信...
基于Linux消息队列的简易聊天室(C语言)(附源代码)
12-01
采用客户-服务器结构，其中服务器实现各个用户的登录并存储相关信息，客户端通过服务器端获取当前登录用户信息，然后各客户进程通过消息队列实现双向通信。 Linux IPC通信利用消息队列消息机制，多线程通信，字符串...
用消息队列实现Client和Server间的通信.rar_message queue_server client_消息队列 _消
09-20
这些系统提供了一套API来创建、发送和接收消息，开发者可以利用这些API在C、C++等语言中实现消息队列的功能。 在“用消息队列实现Client和Server间的通信.txt”文档中，可能会详细介绍如何配置和使用特定的消息队列...
亲测可用基于Linux消息队列的简易聊天室(C语言).zip
05-07
亲测可用的基于Linux消息队列的简易聊天室(C语言)(附源代码)采用客户-服务器结构，其中服务器实现各个用户的登录并存储相关信息，客户端通过服务器端获取当前登录用户信息，然后各客户进程通过消息队列实现双向通信...
分布式消息队列服务器：rabbitmq-server_3.7.14
04-03
RabbitMQ是MQ产品的典型代表，是一款基于AMQP协议可复用的企业消息系统。
游戏服务器的消息队列,游戏服务器的消息队列
weixin_39551103的博客
08-07 523
游戏服务器的消息队列 内容精选换一换华为云分布式消息服务帮助中心，为用户提供产品介绍、用户指南、API参考、最佳实践、常见问题、视频帮助等技术文档，帮助您快速上手使用分布式消息服务。本指南以Kafka队列(非专享版)为例，指导您快速上手分布式消息服务游戏服务器的消息队列 相关内容分布式消息服务(Distributed Message Service，简称DMS)是一项基于高可用分布式集群技术的消息...
浅谈如何自我实现一个消息队列服务器(7）——编写服务器部分
最新发布
m0_63191002的博客
05-10 1052
再次拿出这张图，前面我们已经将重要概念：VirtualHost、exchange、msgQueue、message、binding 都实现了，此时就可以开始编写消息队列MQ的本体：BrokerServer (服务器)，由于消息队列的服务器是一个基于 TCP 协议进行通信的服务器，因此消息队列的 BrokerServer 也叫做 TCP服务器。构造响应对象，设置好响应对象中的值，然后打印 rid、channelId、响应 type、响应 length。方便后续判断当前是哪个连接，连接中的哪一对请求、响应。
怎么安装消息队列服务器,安装和配置消息队列（针对存档服务器）
weixin_39879122的博客
08-02 3339
安装先决条件由于存档服务器的消息队列依靠 Active Directory 域服务 (AD DS) 对目标队列进行加密，因此必须将存档服务器加入到一个域，然后使用“Active Directory 集成”选项安装消息队列；在从属于域的服务器上安装消息队列时，默认将安装此选项。此外，运行消息队列的计算机必须是 Microsoft Windows Authorization Access 组的成员之一...
消息队列
qq_32172681的博客
10-18 1万+
一、什么是消息队列 我们可以把消息队列比作是一个存放消息的容器，当我们需要使用消息的时候可以取出消息供自己使用。消息队列是分布式系统中重要的组件，使用消息队列主要是为了通过异步处理提高系统性能和削峰、降低系统耦合性。 目前使用较多的消息队列有ActiveMQ，RabbitMQ，Kafka，RocketMQ。 二、为什么要用消息队列 我觉得使用消息队列主要有两点好处： 1、通过异步处...
常见的消息队列服务器,消息队列的4个常见应用场景
weixin_36478447的博客
08-13 1246
消息队列的4个常见应用场景分类：云服务资讯编辑：互联网观察浏览量：1932020-12-25 14:07:16几十年前，消息队列开始兴起，它用于连接大型机和服务器应用程序，并逐渐在企业的服务总线与事件总线设计模式、应用间的路由和数据迁移中发挥至关重要的作用。2020年处于移动互联网的下半场，各种技术层出不穷，虽然数据也在爆发式增长，但是高并发、高吞吐已经不再是首要的痛点，稳定、可靠才是王道。本文作...
客户端与服务端通信（Server&Client）的消息队列实现
HiMark
05-15 3411
消息队列 提供从一个进程向另一哥进程发送一块数据的方法 每个数据块都被认为有一个类型，接收者进程收到的数据块可以有不同类型值 消息队列的最大长度，总字节数，消息队列的数都有上限 comm.h #pragma once #include&amp;lt;stdio.h&amp;gt; #include&amp;lt;sys/types.h&amp;gt; #include&amp;lt;sys/ipc.h&amp;g...
利用消息队列实现服务器客户端的通信
哒哒的博客
03-11 2527
1.server.c#include"utili.h"#define SND_TYPE 200 #define RCV_TYPE 100 typedef struct MsgType { long msg_type; char msg_buf[MAX_MSG_LEN]; }MsgType;int main(int argc, char const* argv[]) { key
消息队列MQ的基础知识
热门推荐
u013905744的专栏
06-01 3万+
MQ是什么？RabbitMQ是什么？AMQP是什么？ 消息队列（ message queuing ）使用消息将应用程序连接起来。这些消息通过像RabbitMQ 这样的消息代理服务器在应用程序之间路由。这就像是在应用程序之间放置一个邮局。 RabbitMQ是一个消息代理和队列服务器。 AMQP，即Advanced Message Queuing Protocol，一个提供统一消息服务的应用层标...
Linux的消息队列
08-29
在Linux下，消息队列是通过System V IPC机制提供的。主要的系统调用包括： - `msgget()`：创建或打开一个消息队列，返回一个消息队列标识符。 - `msgsnd()`：向消息队列发送消息。 - `msgrcv()`：从消息队列接收消息...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值