基于消息队列的C/S通信

最新推荐文章于 2024-03-23 20:30:00 发布
最新推荐文章于 2024-03-23 20:30:00 发布
阅读量3k 收藏 2
点赞数 1
分类专栏： 嵌入式 文章标签： 消息队列 通信 vxworks
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/felicitia/article/details/8805666
版权

程序示意图：



程序思路：

         分别写客户端和服务端的函数，在主任务中创建两个client和一个server，考虑到实际情况，应该server的优先级高并且先用taskSpawn函数创建server任务。然后等待客户端获得服务端的应答，则删除队列，程序结束。为了演示client请求，server应答的过程，本次实验采取client发送时发送一个value，在创建任务时给定，每次请求时value加一，服务端获得value之后将该值加一，并根据客户端的id，返回给相应的响应队列。Client函数中首先根据请求队列的大小发送数据，然后开始等待接收响应队列的返回结果。Server函数中等待请求队列不为空，获得请求并返回给对应的响应队列。


关键代码：

main.h
#ifndef MAIN_H_INCLUDED
#define MAIN_H_INCLUDED
#include "vxWorks.h"
#include "semLib.h"
#include "taskLib.h"
#include "msgQLib.h"
#include "sysLib.h"
#include "stdio.h"
#define  CLIENT_TASK_PRI          99
#define  SERVER_TASK_PRI          98
#define  TASK_STACK_SIZE          5000
struct msg
{
    int id;
    int value;
};
LOCAL MSG_Q_ID requestQId;
LOCAL MSG_Q_ID response1QId;
LOCAL MSG_Q_ID response2QId;

LOCAL BOOL notDone;
LOCAL int numMsg = 3;
LOCAL STATUS clientTask (int cid, int value);
LOCAL STATUS serverTask(void);
#endif // MAIN_H_INCLUDED

#include "main.h"
STATUS clientTask(int cid, int value)
{
    int i, j, k;
    struct msg request_msg, response_msg;
    printf ("clientTask started: cid = %d\n", cid);
    for(i=0; i<numMsg; i++)
    {
		request_msg.id = cid;
		request_msg.value = value+i;
       /* semTake(request_semMutex, WAIT_FOREVER);*/
        if (( msgQSend (requestQId, (char *) &request_msg, sizeof (request_msg),
                        WAIT_FOREVER,  MSG_PRI_NORMAL)) == ERROR)
        {
            perror ("Error in sending the message to request queue\n");
            return (ERROR);
        }
        else
        {
            printf ("clientTask: cid = %d, value = %d \n",
                    cid, value+i);
        }
        /*semGive(request_semMutex);*/
    }
/*接收数据从responseQ*/
    if(1 ==  cid)
    {
        for(j=0; j<numMsg; j++)
        {
           /* semTake(response1_semMutex, WAIT_FOREVER);*/
            if (( msgQReceive (response1QId, (char *) &response_msg,
                               sizeof (response_msg), WAIT_FOREVER)) == ERROR)
            {
                perror ("Error in receiving the response1 message\n");
                return (ERROR);
            }
            else
            {
                printf ("clientTask: get msg of value %d from cid = %d\n",
                        response_msg.value, response_msg.id);
            }
        /*    semGive(response1_semMutex);*/
        }

    }
    else if(2 == cid)
    {
        for(k=0; k<numMsg; k++)
        {
       /*     semTake(response2_semMutex, WAIT_FOREVER);*/
            if (( msgQReceive (response2QId, (char *) &response_msg,
                               sizeof (response_msg), WAIT_FOREVER)) == ERROR)
            {
                perror ("Error in receiving the response2 message\n");
                return (ERROR);
            }
            else
            {
                printf ("clientTask: get msg of value %d from cid = %d\n",
                        response_msg.value, response_msg.id);
            }
         /*   semGive(response2_semMutex);*/
        }

    }
	else
	{
		printf("clientTask: cid error!\n");
	}
    notDone = FALSE;
    return (OK);
}

STATUS serverTask(void)
{
	int i;
    struct msg response_msg ;
    printf ("\nserverTask Started \n");
	for(i=0; i<numMsg*2; i++)
	{
	/*	semTake(request_semMutex, WAIT_FOREVER);*/
		if (( msgQReceive (requestQId, (char *) &response_msg,
                       sizeof (response_msg), WAIT_FOREVER)) == ERROR)
		{
			perror ("Error in receiving the message\n");
			return (ERROR);
		}
		else
		{
			printf ("serverTask: get msg of value %d from cid = %d\n",
					response_msg.value, response_msg.id);
		}
		/*semGive(request_semMutex);*/
		/*将获得的value加一后，根据cid发给相应的应答序列*/
		response_msg.value += 1;
		if(response_msg.id==1)
		{
			/*semTake(response1_semMutex, WAIT_FOREVER);*/
			if (( msgQSend (response1QId, (char *) &response_msg, sizeof (response_msg),
							WAIT_FOREVER,  MSG_PRI_NORMAL)) == ERROR)
			{
				perror ("Error in sending the message to response1 queue\n");
				return (ERROR);
			}
			else
			{
				printf ("serverTask sending to response Q1: value = %d \n",
						response_msg.value);
			}
			/*semGive(response1_semMutex);*/
		}
		else if(response_msg.id==2)
		{
			/*semTake(response2_semMutex, WAIT_FOREVER);*/
			if (( msgQSend (response2QId, (char *) &response_msg, sizeof (response_msg),
							WAIT_FOREVER,  MSG_PRI_NORMAL)) == ERROR)
			{
				perror ("Error in sending the message to response2 queue\n");
				return (ERROR);
			}
			else
			{
				printf ("serverTask sending to response Q2: value = %d \n",
						response_msg.value);
			}
			/*semGive(response2_semMutex);*/
		}
		else
		{
			printf("error in response_msg, the id = %d\n", response_msg.id);
		}
	}    
    return (OK);
}

STATUS main()
{
    notDone = TRUE;
   /* request_semMutex = semBCreate(SEM_Q_FIFO, SEM_FULL);
    response1_semMutex = semBCreate(SEM_Q_FIFO, SEM_FULL);
    response2_semMutex = semBCreate(SEM_Q_FIFO, SEM_FULL);*/
    if ((requestQId = msgQCreate(numMsg*2, sizeof (struct msg), MSG_Q_FIFO)) == NULL)
    {
        perror ("Error in creating requestQ");
        return (ERROR);
    }
    if ((response1QId = msgQCreate(numMsg, sizeof (struct msg), MSG_Q_FIFO)) == NULL)
    {
        perror ("Error in creating response1Q");
        return (ERROR);
    }
    if ((response2QId = msgQCreate(numMsg, sizeof (struct msg), MSG_Q_FIFO)) == NULL)
    {
        perror ("Error in creating response2Q");
        return (ERROR);
    }
	if (taskSpawn (" tserverTask ", SERVER_TASK_PRI, 0, TASK_STACK_SIZE,
                   (FUNCPTR) serverTask, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0) == ERROR)
    {
        perror ("serverTask: Error in spawning serverTask");
        return (ERROR);
    }
    if (taskSpawn (" tclientTask ", CLIENT_TASK_PRI, 0, TASK_STACK_SIZE,
                   (FUNCPTR) clientTask, 1, 10, 0, 0, 0, 0, 0, 0, 0, 0)  == ERROR)
    {
        perror ("clientTask: Error in spawning clientTask1");
        return (ERROR);
    }
    if (taskSpawn (" tclientTask ", CLIENT_TASK_PRI, 0, TASK_STACK_SIZE,
                   (FUNCPTR) clientTask, 2, 10, 0, 0, 0, 0, 0, 0, 0, 0) == ERROR)
    {
        perror ("clientTask: Error in spawning clientTask2");
        return (ERROR);
    }
	
    while (notDone)
    {
        taskDelay (sysClkRateGet ());     
    }
	 	if (msgQDelete(requestQId) == ERROR || msgQDelete(response1QId) == ERROR ||
           msgQDelete(response2QId) == ERROR)
        {
            perror ("Error in deleting msgQs");
            return (ERROR);
        }
    return (OK);
}

实验结果：


    可以看出，首先进入了server任务，然后进入client任务，client发送给请求队列消息后，服务端立刻获得value值，因为server优先级高，所以打印发送信息也是在server阻塞后打印的，并且能够看出serverl立刻向相应的响应队列发送了消息，此时value的值比client发过来的值多一，符合程序的设计，后来也是如此。直到client1的请求都被响应了，client1从自己的响应队列中得到加一后的值，之后client2也同理。

下面是windview演示结果：

第一幅能看出t1即主任务创建了三个任务，然后切换到Server，但是server被阻塞，因为请求队列为空，又切换到client1，当client1有请求之后再切换到server给予响应，依次进行，client2也是如此。



下图是过了一段时间的截图，因为主程序一直在等待客户端接收到响应队列的消息，结束之后能从下图看出删除了请求队列和响应队列1，响应队列2，程序结束。


遇到问题：

1、  C语言的单行注释“//”不能使用，编译不能通过。

2、  刚开始使用二进制信号量控制队列只能有一个任务在发送或接受，造成死锁。发送之前将请求队列take，然后发送，由于server优先级高，此时还没有来得及释放信号量就切换到server任务，server接收请求队列获取不到信号量，造成一直等待的死锁局面。

3、  刚开始没有考虑实际情况，先创建了client1，client2，并且优先级设定为一致，而事实上应该先启动服务器在允许客户端请求，故更改顺序，先创建server任务。

4、用windview观察的时候要选择task state transition，刚开始使用默认的context switch观察不到想要的结果。之后观察成功，鼠标悬停就能看到相关的信息，非常方便。

felicitia
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
消息队列通讯编程
zhuwenfeng的专栏
05-06 511
1.基本概念 消息队列就是一个消息的链表。而一条消息则可看做是一个记录，具有特定的格式 进程可以按照一定的规则添加新消息；另一些进程则可以从消息队列中读走消息。 2.函数学习 创建消息队列 函数名：msgget 函数原型：int msgget(key_t key,int msgflg) 函数功能：打开或创建消息队列 头文件：  返回值：成功：返回消息队列的id  失败：-1 参
用消息队列编写一个客户端服务器通信的程序
陈龙的专栏
09-20 6610
实验原理：     本实验用消息队列设计一个简易的双人聊天程序（一个服务器，两个客户端）。消息队列重点在于消息类型的匹配，客户端和服务端的“通信协议”的设计。思想如下：   服务器端：接受客户端发来的任何消息，并根据器消息类型，转发给对应的客户端。同时，检测是否有退出标记，有
利用消息队列实现进程间通信
03-21
利用消息队列基本函数，实现Linux系统下进程A和进程B之间的消息收发。 msgsend输入‘end’，退出程序
Linux C下的System V和POSIX消息队列详解
最新发布
深耕嵌入式领用多年， 致力于分享嵌入式领域技术!
03-23 561
Linux C下的System V和POSIX消息队列详解
进程通信之消息队列
xy913741894的博客
05-17 903
在前面，我们了解进程通信的概念以及常见的进程通信方式，我做个整理如下图：我们继续通过实例来学习进程通信，今天主要是讲消息队列是如何实现进程通信的，代码均在Ubuntu16.04下测试。如上图所示，消息队列是一种间接的通信方式，它提供了一种从一个进程向另一个进程发送一个数据块的方法。 每个数据块都被认为含有一个类型，接收进程可以独立地接收含有不同类型的数据结构。我们可以通过发送消息来避免命名管道的同
任务2：消息队列通信实现一个简单的客户/服务器应用，多个客户进程task42c可并发地向服务器进程发送消息，服务器task42s向每个客户发送消息接收回执。
weixin_45950398的博客
05-13 1750
任务2：编写消息队列通信程序task42s.c和task42c.c，利用消息队列通信实现一个简单的客户/服务器应用，多个客户进程task42c可并发地向服务器进程发送消息，服务器task42s向每个客户发送消息接收回执。比如进程PID为1234的客户端发送的消息为”hello from Process 1234”，服务器收到该消息后发回消息为“receipt of hello from <您的姓名xxx>’s server to Process 1234”TOC](这里写自定义目录标题) 消息队
基于python实现简单C/S模式代码实例
09-16
基于Python实现的C/S模式，允许我们利用Python的强大功能和易读性来构建高效且灵活的网络通信程序。下面我们将深入探讨如何使用Python编写简单的C/S模式代码。 首先，让我们分析服务器端的代码： ```python import...
项目-银行账户管理系统（linux C编程和 消息队列实现IPC编程）.rar
09-01
采用C/S架构进行设计 客户端：提供一个界面供用户选择，当用户选择具体的业务操作之后，客户端将用户的选择信息发送给服务器进行处理，客户端等待服务器的结果，并且显示给客户。 服务器：接收客户端发来的用户...
python基于C/S模式实现聊天室功能
09-19
在本文中，我们将探讨如何使用Python基于C/S（客户机/服务器）模式实现一个简单的聊天室功能。C/S模式是一种网络通信架构，其中客户端发起请求，服务器响应这些请求。在聊天室场景中，服务器需要处理多个客户端的...
模拟ATM机使用C/S架构的小程序源码
07-17
恩，使用了C/S架构，多线程机制，消息队列通信，SQLite3数据库。别的到没什么。写的时间还蛮长的，当时还不成熟嘛！ 因为链接了libsqllite3.so，所以你得安装libsqite3这个库。 和大家分享下，记得回复下哦！
weaving-socket，已.net core为基础，设计基于TCP通信的交互框架 是编写物联网，消息队列，IM等完美的选择
01-11
是编写物联网，消息队列，websocket应用，移动通信应用，IM等完美的选择。 可规范先后台交互处理，可支持，B/C,C/S,手机移动标准化的通信方式。支持 Json, Bytes, custom 多种方式，分别代表，内置json协议，内置二...
linux下C语言编程（进程通信、消息队列）
11-22
Linux操作系统下C语言的进程通信、消息队列
采用消息队列实现客户端与服务端的通信
02-14
采用消息队列实现客户端与服务端之间的通信。
linux下用socket,子进程,消息队列编写的消息传送
07-29
这是在linux下用socket,子进程,消息队列编写的简单的客户端和服务器间通信的程序，客户端发送数据给服务器，服务器使用消息队列把消息存到文件中，用make运行Makefile编译程序
使用消息队列与共享内存完成一个简单的终端聊天程序
08-09
使用消息队列与共享内存完成一个简单的终端聊天程序
linux使用消息队列实现进程间双向通信
03-03
使用linux消息队列实现进程间双向通信。本接口将消息接收封装在一个独立线程中，方便使用。
课题六 - 消息队列实现客户机通信
treblez's blog
06-29 1610
帮别人做的操作系统课设，一道很好的题目，功能是用消息队列实现客户机与服务器的连接。 难点在于不要把.c后缀写成.cpp 文章目录要求思路代码运行截图 要求 思路 服务端：使用约定的key_t创建公共消息队列，使用两个msgrcv函数语句等待获取两个私有消息队列的id，获取之后分别发送给另外一方。 因为结构必须被定义为一个类型码和一个数组，所以要注意字符串和int的转换。 客户端：创建私有消息队列连接公共消息队列，创建两个线程，一个用于消息发送，一个用于消息接收。 注意消息队列传参时候的指针引用和解引用。
使用消息队列实现进程间的通信（代码实例）
qq_43165314的博客
04-03 5950
分别编写代表两个人的程序，他们之间用消息队列进行通信，注意箭头是双向的！注意： 1. Jack与Rose必须可以同时收与发 2. Jack发送了“quit”给对方，自己与Rose都要退出 ...
使用消息队列进行进程间通信（代码实例）
modi000的博客
07-24 1778
使用消息队列进行进程间通信（代码实例） v 消息队列间的通信方式 1.消息队列提供了一种从一个进程向另一个进程发送一个数据块的方法。 每个数据块都被认为含有一个类型，接收进程可以独立地接收含有不同类型的数据结构。也就是你先要接收那个进程的消息,你就要知道这个消息的类型。 2.那么这个数据块到底是专门定义的呢?我们又是否可以自己定义呢？ 其实,Linux下的man手册里面就给出了定义.使用命令:man 2 magsnd (man手册第二章)即可查阅。 以下是定义:（自己也可以定义,注意...
使用消息队列实现不同进程间的通信
06-01
消息队列是一种进程间通信的方式，可以用于不同进程之间的通信。它基于消息的异步传递，即一个进程把消息放入消息队列中，而另一个进程从队列中获取消息。 实现消息队列的主要步骤如下： 1. 创建消息队列。创建消息队列需要指定消息队列的键值和权限等信息。 2. 发送消息。在发送消息时，需要指定消息队列的标识符、消息类型和消息内容等信息。 3. 接收消息。在接收消息时，需要指定消息队列的标识符和消息类型等信息。 以下是一个使用消息队列实现进程间通信的简单示例： ```c #include <stdio.h> #include <stdlib.h> #include <sys/msg.h> #include <unistd.h> #define MSG_SIZE 1024 typedef struct { long type; char text[MSG_SIZE]; } message; int main() { int msgid; key_t key; message msg; // 创建消息队列 key = ftok(".", 'a'); if ((msgid = msgget(key, IPC_CREAT|0666)) == -1) { perror("msgget error"); exit(1); } // 发送消息 msg.type = 1; sprintf(msg.text, "Hello, this is message from process %d", getpid()); if (msgsnd(msgid, &msg, sizeof(msg.text), 0) == -1) { perror("msgsnd error"); exit(1); } // 接收消息 if (msgrcv(msgid, &msg, sizeof(msg.text), 1, 0) == -1) { perror("msgrcv error"); exit(1); } printf("Received message: %s\n", msg.text); // 删除消息队列 if (msgctl(msgid, IPC_RMID, NULL) == -1) { perror("msgctl error"); exit(1); } return 0; } ``` 该示例中，首先创建一个消息队列，然后在发送进程中向消息队列中发送一条消息，接收进程从消息队列中接收消息并输出。最后删除消息队列。注意，发送和接收进程需要共享消息队列的标识符，可以通过 ftok() 函数生成一个唯一的键值来实现。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值