linux套接字自定义数据队列,Linux编程之自定义消息队列

最新推荐文章于 2023-06-24 17:09:46 发布
最新推荐文章于 2023-06-24 17:09:46 发布
阅读量125 收藏
点赞数
文章标签： linux套接字自定义数据队列

我这里要讲的并不是IPC中的消息队列，我要讲的是在进程内部实现自定义的消息队列，让各个线程的消息来推动整个进程的运动。进程间的消息队列用于进程与进程之间的通信，而我将要实现的进程内的消息队列是用于有序妥当处理来自于各个线程请求，避免一窝蜂的请求而导致消息的异常丢失。想想socket编程里的listen函数吧，里面要设置一个队列长度的参数，其实来自网络的请求已经排成一个请求队列了，只是这个队列是系统帮我们做好了，我们看不到而已。如果系统不帮我们做这个等待队列的话，那就需要我们程序员在应用层实现了。

进程内的消息队列实现并不难，总的来说有以下几点：自定义消息结构，并构造队列

一个线程负责依次从消息队列中取出消息，并处理该消息

多个线程产生事件，并将消息放进消息队列，等待处理

长话短说，我们开始动手吧！

一、定义消息结构

先贴代码再解释：

69c5a8ac3fa60e0848d784a6dd461da6.pngtypedef struct Msg_Hdr_s  

{

uint32 msg_type;

uint32 msg_len;

uint32 msg_src;

uint32 msg_dst;

}Msg_Hdr_t;

typedef struct Msg_s

{

Msg_Hdr_t hdr;

uint8 data[100];

} Msg_t;

69c5a8ac3fa60e0848d784a6dd461da6.png

下面是我设计的消息格式内容的解释：msg_type：标记消息类型，当消息接收者看到该msg_type后就知道他要干什么事了

msg_len：消息长度，待扩展，暂时没用到(以后会扩展为变长消息)

msg_src：消息的源地址，即消息的发起者

msg_dst：消息的目的地，即消息的接受者

data[100]:消息除去消息头外可以携带的信息量，定义为100字节

由该消息数据结构可以知道，这个消息是定长的，当然也可以实现为变长消息，但现在暂不实现，今天先把定长消息实现了，以后再完善变长消息。

二、构造循环队列

队列可以由链表实现，也可以由数组实现，这里就使用数组实现的循环链表作为我们消息队列的队列模型。

69c5a8ac3fa60e0848d784a6dd461da6.pngtypedef struct Queue_s  

{

int head;

int rear;

sem_t sem;

Msg_t data[QUEUE_SIZE];

}Queue_t;

int MsgQueueInit(Queue_t* Q)

{

if(!Q)

{

printf("Invalid Queue!\n");

return -1;

}

Q->rear = 0;

Q->head = 0;

sem_init(&Q->sem, 0, 1);

return 0;

}

int MsgDeQueue(Queue_t* Q, Msg_t* msg)

{

if(!Q)

{

printf("Invalid Queue!\n");

return -1;

}

if(Q->rear == Q->head) //only one consumer,no need to lock head

{

printf("Empty Queue!\n");

return -1;

}

memcpy(msg, &(Q->data[Q->head]), sizeof(Msg_t));

Q->head = (Q->head+1)%QUEUE_SIZE;

return 0;

}

int MsgEnQueue(Queue_t* Q, Msg_t* msg)

{

if(Q->head == (Q->rear+1)%QUEUE_SIZE)

{

printf("Full Queue!\n");

return -1;

}

sem_wait(&Q->sem);

memcpy(&(Q->data[Q->rear]), msg, sizeof(Msg_t));

Q->rear = (Q->rear+1)%QUEUE_SIZE;

sem_post(&Q->sem);

return 0;

}

69c5a8ac3fa60e0848d784a6dd461da6.png

循环队列的实现想必大家都比较熟悉，但这里需要提示的几点是：队列中应加入信号量或锁来保证进队时的互斥访问，因为多个消息可能同时进队，互相覆盖其队列节点

这里的信号量仅用于进队而没用于出队，理由是消息处理者只有一个，不存在互斥的情形

三、构造消息处理者

69c5a8ac3fa60e0848d784a6dd461da6.pngif(pthread_create(&handler_thread_id, NULL, (void*)msg_handler, NULL))  

{

printf("create handler thread fail!\n");

return -1;

}

void msg_printer(Msg_t* msg)

{

if(!msg)

{

return;

}

printf("%s: I have recieved a message!\n", __FUNCTION__);

printf("%s: msgtype:%d   msg_src:%d  dst:%d\n\n",__FUNCTION__,msg->hdr.msg_type,msg->hdr.msg_src,msg->hdr.msg_dst);

}

void msg_handler()

{

sleep(5);  //let's wait 5s when starts

while(1)

{

Msg_t msg;

memset(&msg, 0 ,sizeof(Msg_t));

int res = MsgDeQueue((Queue_t*)&MsgQueue, &msg);

if(res != 0)

{

sleep(10);

continue;

}

msg_printer(&msg);

sleep(1);

}

}

69c5a8ac3fa60e0848d784a6dd461da6.png

我在进程里create了一个线程作为消息处理者(handler)来处理消息队列的消息，甘进入该线程时先等个5秒钟来让生产者往队列里丢些消息，然后再开始消息处理。当队列没消息可取时，就休息十秒，再去取消息。

这里的消息处理很简单，我只是简单地将受到的消息打印一下，证明受到的消息正是其他线程发给我的。当然，新航道雅思培训你也可以在这里扩展功能，根据受到的消息类型进一步决定该做什么事。比如：

69c5a8ac3fa60e0848d784a6dd461da6.pngenum MSG_TYPE  

{

GO_HOME,

GO_TO_BED,

GO_TO_LUNCH,

GO_TO_CINAMA,

GO_TO_SCHOOL,

GO_DATEING,

GO_TO_WORK,//6

};

void handler()

{

switch(msgtype)

{

case GO_HOME: go_home(); break;

case GO_TO_BED:  go_to_bed(); break;

.......

}

}

69c5a8ac3fa60e0848d784a6dd461da6.png

这里的handler就是一个简单的状态机了，根据给定的消息类型(事件)去做特定的事，推动状态机的转动。

四、构造消息生产者

69c5a8ac3fa60e0848d784a6dd461da6.pngif(pthread_create(&thread1_id, NULL, (void*)msg_sender1, NULL))  

{

printf("create thread1 fail!\n");

return -1;

}

if(pthread_create(&thread2_id, NULL, (void*)msg_sender2, NULL))

{

printf("create thread2 fail!\n");

return -1;

}

if(pthread_create(&thread3_id, NULL, (void*)msg_sender3, NULL))

{

printf("create thread3 fail!\n");

return -1;

}

void msg_sender1()

{

int i = 0;

while(1)

{

if(i > 10)

{

i = 0;

}

Msg_t msg;

msg.hdr.msg_type = i++;

msg.hdr.msg_src = THREAD1;

msg.hdr.msg_dst = HANDLER;

MsgEnQueue((Queue_t*)&MsgQueue, &msg);

printf("%s: Thread1 send a message!\n",__FUNCTION__);

sleep(1);

}

}

void msg_sender2()

{

int i = 0;

while(1)

{

if(i > 10)

{

i = 0;

}

Msg_t msg;

msg.hdr.msg_type = i++;

msg.hdr.msg_src = THREAD2;

msg.hdr.msg_dst = HANDLER;

MsgEnQueue((Queue_t*)&MsgQueue, &msg);

printf("%s: Thread2 send a message!\n",__FUNCTION__);

sleep(1);

}

}

void msg_sender3()

{

int i = 0;

while(1)

{

if(i > 10)

{

i = 0;

}

Msg_t msg;

msg.hdr.msg_type = i++;

msg.hdr.msg_src = THREAD3;

msg.hdr.msg_dst = HANDLER;

MsgEnQueue((Queue_t*)&MsgQueue, &msg);

printf("%s: Thread3 send a message!\n",__FUNCTION__);

sleep(1);

}

}

69c5a8ac3fa60e0848d784a6dd461da6.png

这里我create了三个线程来模拟消息生产者，每个生产者每隔1秒往消息队列里写消息。

五、跑起来看看

先贴完整的代码：

msg_queue.c:

69c5a8ac3fa60e0848d784a6dd461da6.png1 #include   

2 #include 

3 #include 

4 #include 

5 #include 

6 #include "msg_def.h"

7

8 Queue_t MsgQueue;

9

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

11 {

12     int ret;

13     pthread_t thread1_id;

14     pthread_t thread2_id;

15     pthread_t thread3_id;

16     pthread_t handler_thread_id;

17

18     ret = MsgQueueInit((Queue_t*)&MsgQueue);

19     if(ret != 0)

20     {

21         return -1;

22     }

23

24     if(pthread_create(&handler_thread_id, NULL, (void*)msg_handler, NULL))

25     {

26         printf("create handler thread fail!\n");

27         return -1;

28     }

29

30

31     if(pthread_create(&thread1_id, NULL, (void*)msg_sender1, NULL))

32     {

33         printf("create thread1 fail!\n");

34         return -1;

35     }

36

37     if(pthread_create(&thread2_id, NULL, (void*)msg_sender2, NULL))

38     {

39         printf("create thread2 fail!\n");

40         return -1;

41     }

42

43     if(pthread_create(&thread3_id, NULL, (void*)msg_sender3, NULL))

44     {

45         printf("create thread3 fail!\n");

46         return -1;

47     }

48

49

50     while(1)

51     {

52         sleep(1);

53     }

54

55     return 0;

56 }

57

58

59

60

61 int MsgQueueInit(Queue_t* Q)

62 {

63     if(!Q)

64     {

65         printf("Invalid Queue!\n");

66         return -1;

67     }

68     Q->rear = 0;

69     Q->head = 0;

70     sem_init(&Q->sem, 0, 1);

71     return 0;

72 }

73

74 int MsgDeQueue(Queue_t* Q, Msg_t* msg)

75 {

76     if(!Q)

77     {

78         printf("Invalid Queue!\n");

79         return -1;

80     }

81     if(Q->rear == Q->head) //only one cosumer,no need to lock head

82     {

83         printf("Empty Queue!\n");

84         return -1;

85     }

86     memcpy(msg, &(Q->data[Q->head]), sizeof(Msg_t));

87     Q->head = (Q->head+1)%QUEUE_SIZE;

88     return 0;

89

90 }

91

92 int MsgEnQueue(Queue_t* Q, Msg_t* msg)

93 {

94     if(Q->head == (Q->rear+1)%QUEUE_SIZE)

95     {

96         printf("Full Queue!\n");

97         return -1;

98     }

99     sem_wait(&Q->sem);

100     memcpy(&(Q->data[Q->rear]), msg, sizeof(Msg_t));

101     Q->rear = (Q->rear+1)%QUEUE_SIZE;

102     sem_post(&Q->sem);

103     return 0;

104 }

105

106 void msg_printer(Msg_t* msg)

107 {

108     if(!msg)

109     {

110         return;

111     }

112     printf("%s: I have recieved a message!\n", __FUNCTION__);

113     printf("%s: msgtype:%d   msg_src:%d  dst:%d\n\n",__FUNCTION__,msg->hdr.msg_type,msg->hdr.msg_src,msg->hdr.msg_dst);

114

115 }

116

117 int msg_send()

118 {

119

120     Msg_t msg;

121     msg.hdr.msg_type = GO_HOME;

122     msg.hdr.msg_src = THREAD1;

123     msg.hdr.msg_dst = HANDLER;

124     return MsgEnQueue((Queue_t*)&MsgQueue, &msg);

125

126 }

127

128 void msg_handler()

129 {

130     sleep(5);  //let's wait 5s when starts

131     while(1)

132     {

133         Msg_t msg;

134         memset(&msg, 0 ,sizeof(Msg_t));

135         int res = MsgDeQueue((Queue_t*)&MsgQueue, &msg);

136         if(res != 0)

137         {

138             sleep(10);

139             continue;

140         }

141         msg_printer(&msg);

142         sleep(1);

143     }

144 }

145

146

147 void msg_sender1()

148 {

149     int i = 0;

150     while(1)

151     {

152         if(i > 10)

153         {

154             i = 0;

155         }

156         Msg_t msg;

157         msg.hdr.msg_type = i++;

158         msg.hdr.msg_src = THREAD1;

159         msg.hdr.msg_dst = HANDLER;

160         MsgEnQueue((Queue_t*)&MsgQueue, &msg);

161         printf("%s: Thread1 send a message!\n",__FUNCTION__);

162         sleep(1);

163     }

164 }

165

166 void msg_sender2()

167 {

168     int i = 0;

169     while(1)

170     {

171         if(i > 10)

172         {

173             i = 0;

174         }

175         Msg_t msg;

176         msg.hdr.msg_type = i++;

177         msg.hdr.msg_src = THREAD2;

178         msg.hdr.msg_dst = HANDLER;

179         MsgEnQueue((Queue_t*)&MsgQueue, &msg);

180         printf("%s: Thread2 send a message!\n",__FUNCTION__);

181         sleep(1);

182     }

183 }

184

185 void msg_sender3()

186 {

187     int i = 0;

188     while(1)

189     {

190         if(i > 10)

191         {

192             i = 0;

193         }

194         Msg_t msg;

195         msg.hdr.msg_type = i++;

196         msg.hdr.msg_src = THREAD3;

197         msg.hdr.msg_dst = HANDLER;

198         MsgEnQueue((Queue_t*)&MsgQueue, &msg);

199         printf("%s: Thread3 send a message!\n",__FUNCTION__);

200         sleep(1);

201     }

202 }

69c5a8ac3fa60e0848d784a6dd461da6.png

msg_def.h:

69c5a8ac3fa60e0848d784a6dd461da6.png1 #include   

2 #include 

3 #include 

4

5 typedef unsigned char uint8;

6 typedef unsigned short unit16;

7 typedef unsigned int uint32;

8

9 #define QUEUE_SIZE 1000

10

11 typedef struct Msg_Hdr_s

12 {

13     uint32 msg_type;

14     uint32 msg_len;

15     uint32 msg_src;

16     uint32 msg_dst;

17 }Msg_Hdr_t;

18

19 typedef struct Msg_s

20 {

21     Msg_Hdr_t hdr;

22     uint8 data[100];

23 } Msg_t;

24

25 typedef struct Queue_s

26 {

27     int head;

28     int rear;

29     sem_t sem;

30     Msg_t data[QUEUE_SIZE];

31 }Queue_t;

32

33 typedef struct Queue_s QueueNode;

34

35 enum MSG_TYPE

36 {

37     GO_HOME,

38     GO_TO_BED,

39     GO_TO_LUNCH,

40     GO_TO_CINAMA,

41     GO_TO_SCHOOL,

42     GO_DATEING,

43     GO_TO_WORK,//6

44 };

45

46 enum SRC_ADDR

47 {

48     THREAD1,

49     THREAD2,

50     THREAD3,

51     HANDLER,

52 };

53

54

55 int MsgQueueInit(Queue_t* Q);

56 int MsgDeQueue(Queue_t* Q, Msg_t* msg);

57 int MsgEnQueue(Queue_t* Q, Msg_t* msg);

58 void msg_handler();

59 void msg_sender1();

60 void msg_sender2();

61 void msg_sender3();

62 void msg_printer(Msg_t* msg);

63 int msg_send();

69c5a8ac3fa60e0848d784a6dd461da6.png

看看跑起来的现象：

1db37154a2771dfad5924406edadd6de.png

Finish!

现在这套进程内的消息队列的架构在实际工程中非常实用(当然实际工程的框架会复杂健壮得多)，很多工程都需要这种基于事件推动的思想来保证每条请求都可以有条不絮地执行，所以这个框架也是有用武之地的，尤其配合状态机非常适合！

贾小阳
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
关于Linux消息队列的简单说明、使用、编码
weixin_44903538的博客
06-05 519
关于Linux消息队列的简单说明、使用、编码
LinuxSockets：学习在Linux中通过套接字传递消息
02-13
本教程将深入讲解如何在Linux环境中利用C++编程语言创建和使用套接字来传递消息。 一、套接字基础 套接字是操作系统提供的一种接口，它允许程序之间进行数据交换，可以跨越同一台计算机的不同进程，甚至跨越网络...
linux 驱动基础 - 三、linux 队列
最新发布
sty01z的博客
06-24 435
工作队列（work queue）是一种将工作推后执行的形式，它和tasklet有所不同。工作队列可以把工作推后，交由一个内核线程去执行，也就是说，这个下半部分可以在进程上下文中执行。这样，通过工作队列执行的代码能占尽进程上下文的所有优势。最重要的就是工作队列允许被重新调度甚至是睡眠。等待队列从功能上可以简单理解为：让进程进入睡眠，在你想让他工作的时候唤醒。它有两部分组成首先是挂接我们等待队列项的等待头，等待队列头的数据结构描述如下。而挂接在其上面的等待队列项的数据局结构如下。他们的创建与与初始化如下。
循环消息队列
立哥_blog
02-23 369
循环消息队列 拿下面为例子 结构 结构图 OS_Q结构相当于循环队列的指针 m_video_qmem是循环队列所占的具体空间 相关函数 OSQPost 向队列中post一个成员，尾指针tail加一 参数 OS_Q* pq    指针变量 void* pmsg 待post的数据 返回值 post情况：若队列满了就返回FULL， 否则返回0表示成功 实现 注意 在对OS_
循环队列 作为消息队列
leiting_imecas的博客
06-12 708
为了避免消息队列频繁的申请和释放内存，采用循环队列作为消息队列。 queue.h: #ifndef INC_QUEUE_H_ #define INC_QUEUE_H_ #include #include using namespace std; #define MAX_QUEUE_SIZE 500000 #define SINGLE_DATA_SIZE 1024 clas
Linux下进程间通信 之 消息队列
12-18 719
消息队列是内核地址空间中的内部链表，通过linux内核在各个进程直接传递内容，消息顺序 地发送到消息队列中，并以几种不同的方式从队列中获得，每个消息队列可以用 IPC标识符 唯一 地进行识别。内核中的消息队列是通过IPC的标识符来区别，不同的消息队列直接是相互独立的。 每个消息队列中的消息，又构成一个 独立的链表。 消息队列克服了信号承载信息量少，管道只能承载无格式字符流。 （1）消息缓冲区结构： // 头文件 #include <sys/types....
11_linux消息队列专题讲座-王保明.rar
12-12
王保明的讲座可能还会讨论到与其他IPC机制（如管道、共享内存、套接字等）的比较，以及在现代Linux系统中，如POSIX消息队列的使用等更高级的话题。通过学习这个专题，开发者能够更好地理解和利用Linux消息队列来设计...
linux下网络编程TCP客户端和服务器端数据传输代码
01-14
在Linux环境下进行网络编程，TCP...总结来说，Linux下的TCP网络编程涉及到套接字的创建、连接建立、数据传输以及关闭连接等一系列过程，是实现跨网络通信的基础。理解并熟练掌握这些知识，对于开发网络应用至关重要。
linux_net.rar_LINUX NET_linux 网络编程_linux网络编程
09-22
它需要两个参数：套接字描述符和最大连接队列长度。 4. `connect.c`：在客户端，`connect()`函数用于建立到服务器的连接。它需要一个套接字描述符，以及服务器的地址和端口信息。 5. `read.c`：`read()`函数用于从...
icp-native.rar_Linux/Unix编程_Unix_Linux_
08-11
"icp-native.c"可能包含了与特定的“icp”（可能是“Inter-Computer Protocol”或某种自定义协议）相关的本地实现，这通常涉及到套接字编程，包括创建、绑定、监听、接受连接以及数据传输等步骤。开发者可能使用了...
Android之循环队列操作
02-02
队列特性：先进先出（FIFO)——先进队列的元素先出队列。下面以一个简单的例子实现循环队列的操作。博客地址：http://blog.csdn.net/bingdianlanxin，有问题欢迎留言。
【Linux】进程间通信之消息队列
modi000的博客
07-24 125
在上一篇博客里，我们学习了进程间通信的一种方式，那就是管道，今天我们继续学习另一种方式消息队列。 消息队列 一. 什么是消息队列？ 　　消息队列是消息的链表，存放在内核中并由消息队列标识符表示。 　　消息队列提供了一个从一个进程向另一个进程发送数据块的方法，每个数据块都可以被认为是有一个类型，接受者接受的数据块可以有不同的类型。 　　但是同管道类似，它有一个不足就是每个消息的最大长度是有上限的(MSGMAX)，每个消息队列的总的字节数(MSGMNB)，系统上消息队列的总数上限(MSGMNI)。可以用c..
Message Queue（消息队列）以及Handler介绍
【小喵】的博客
03-23 465
Message Queue UI线程绑定了一个数据结构Message Queue，其以队列（FIFO)方式保存Message对象，UI线程以一个Looper对象（获取方法Looper.getMainLooper())以循环的方式监视附送是否有Message对象，如果发现有非null的Message对象，即进行回调处理。 队列中的Message由与UI线程绑定的Handler对象（n
java socket 属性设置
热门推荐
FastThinking的专栏
09-02 1万+
//解析服务器地址和端口号 int dotPos = ipAddr.indexOf(':'); String ip = ipAddr.substring(0, dotPos).trim(); int port = Integer.parseInt(ipAddr.substring(dotPos+1).trim()); InetSocketAddress endpoint = new
【Go并发】循环队列及条件锁实现goroutine间的通信
js010111的博客
07-03 412
基于循环队列及条件锁实现goroutine间的通信。
浅聊 消息队列和事件循环（eventloop）
A_Common_Man的博客
05-16 626
消息队列和事件循环
实现进程内的消息队列——让请求排起队来
Don't let your dreams be dreams
01-04 5838
我这里要讲的并不是IPC中的消息队列，我要讲的是在进程内部实现自定义的消息队列，让各个线程的消息来推动整个进程的运动。进程间的消息队列用于进程与进程之间的通信，而我将要实现的进程内的消息队列是用于有序妥当处理来自于各个线程请求，避免一窝蜂的请求而导致消息的异常丢失。想想socket编程里的listen函数吧，里面要设置一个队列长度的参数，其实来自网络的请求已经排成一个请求队列了，只是这个队列是系统
ros踩坑之路 创建src和msg
智渊的博客
03-24 594
先附上ros 教程链接：http://wiki.ros.org/ROS/Tutorials/CreatingMsgAndSrv 先讲一下msg文件和srv文件的作用， msg文件： 用于表述ros 中msg的类型（field)，并将其生成源文件 srv文件：用来描述一个服务，指定其输入和输出的参数类型 msg部分： roscd beginner_tutorials mkdir msg echo "int64 num" > msg/Num.msg 修改pckage.xml，添加依赖.
Linux网络编程：面向连接的传输层套接字解析
除了常见的应用层和传输层套接字，还有允许直接操作网络层（IP）的原始套接字（SOCK_RAW）和数据链路层（如以太网）的套接字，这些套接字主要用于实现自定义协议或者抓包分析。 总结来说，Linux网络编程涉及到从...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值