目录
一:ZMQ简介
二:ZMQ的request-reply模式
三:ZMQ的pub-sub模式
官方介绍:ZeroMQ (also known as ØMQ, 0MQ, or zmq) looks like an embeddable networking library but acts like a concurrency framework. It gives you sockets that carry atomic messages across various transports like in-process, inter-process, TCP, and multicast. You can connect sockets N-to-N with patterns like fan-out, pub-sub, task distribution, and request-reply. It’s fast enough to be the fabric for clustered products. Its asynchronous I/O model gives you scalable multicore applications, built as asynchronous message-processing tasks. It has a score of language APIs and runs on most operating systems.
大概的意思就是:zmq看上去像是一个lib库,我们调用lib库里的函数来实现socket通信,但是其支持的功能远不止如此。可利用zmq进行消息的传递,无论消息是进程间的,程序内的传递,还是以TCP,多播方式传递。你可以使用套接字构建多对多的连接模式,如扇出、发布-订阅、任务分发、请求-应答等。ZMQ的快速足以胜任集群应用产品。它的异步I/O机制让你能够构建多核应用程序,完成异步消息处理任务。ZMQ有着多语言支持,并能在几乎所有的操作系统上运行。
为什么会接触到ZMQ,工作中有个需求就是有套用C语言写的测试工具,其在后台会在运行过程中产生一系列的测试数据,现需要将测试数据用图表动态的展示出来。用的是FLASK框架,则会产生一个需求,如何将测试工具产生的数据传递到FLASK框架里去给到前端去显示。FLASK用的是PYTHON代码,最开始想到的是用RABBITMQ,虽然其功能丰富,但是RABBITMQ对于此需求有点大材小用,于是想寻求一个轻量级的消息传递组件,ZMQ正好符合此需求,事实上在开发的过程中,其大大简化了socket编程,仅仅使用几个其提供的API即可完成进程间的通信。
下面会根据上述需求给出穿刺代码
使用REQ-REP套接字发送和接受消息是需要遵循一定规律的。客户端首先使用zmq_send()发送消息,再用zmq_recv()接收,如此循环(这里所谓的客户端就是发消息的一方,服务端就是接收消息回响应的一方)。此模式支持阻塞式的和非阻塞式的。非阻塞式的,客户端可以不管服务端有没有接收到消息,一直不断的发。本次需求采用非阻塞式的,因为工具测试的时候可不能因为服务端没有收到消息,不回响应而停在那。
下面同时给出C语言版本和python版本的zmq代码
C语言:
服务端
#include
#include
#include
#include
#include
int main(void)
{
void * context = zmq_ctx_new();
void * socket = zmq_socket(context, ZMQ_REP);
zmq_connect(socket, "tcp://localhost:5555");
char buffer[100] = {0};
while(1)
{
int bytes = zmq_recv(socket, buffer, 100, 0);
printf("recv message from client:%s\n",buffer);
sleep(1);
const char * replyMsg = "I am xiaoming";
bytes = zmq_send(socket, replyMsg, strlen(replyMsg), 0);
}
zmq_close(socket);
zmq_ctx_destroy(context);
return 0;
}
客户端:
#include
#include
#include
static void s_send(void *socket, char *string)
{
// 初始化一个zmq_msg_t对象, 分配的大小为string的大小
zmq_msg_t msg;
zmq_msg_init_size(&msg, strlen(string));
memcpy(zmq_msg_data(&msg), string, strlen(string));
// 发送数据
//printf("send data! %s\n",msg);
int rc = zmq_msg_send(&msg, socket, ZMQ_DONTWAIT);
if(rc == -1)
{
printf("send dptData faild!");
}
// 关闭zmq_msg_t对象
zmq_msg_close(&msg);
}
int main (void)
{
// Socket to talk to clients
void *context = zmq_ctx_new ();
void *requester = zmq_socket (context, ZMQ_REQ);
int rc = zmq_bind (requester, "tcp://*:5555");
char input[100] = {0};
char buffer[100] = {0};
while (1)
{
snprintf(input,100,"who are you?");
s_send(requester,input);
zmq_recv (requester, buffer, 100, 0);
printf("recv message from server:%s\n",buffer);
memset(input,0,100);
memset(buffer,0,100);
}
return 0;
}
编译:
gcc zmqclient.c -o zmqclient -lzmq
gcc zmqserver.c -o zmqserver -lzmq
先起客户端,其打印如下:
send dptData faild!recv message from server:
send dptData faild!recv message from server:
send dptData faild!recv message from server:
send dptData faild!recv message from server:
send dptData faild!recv message from server:
send dptData faild!recv message from server:
recv message from server:I am xiaoming
recv message from server:I am xiaoming
recv message from server:I am xiaoming
recv message from server:I am xiaoming
recv message from server:I am xiaoming
可以看到在非阻塞的方式下,客户端起来后,也不管服务端有没有连上,先发了再说,也不会阻塞在那。
起服务端,其打印如下:
recv message from client:who are you?
recv message from client:who are you?
recv message from client:who are you?
recv message from client:who are you?
recv message from client:who are you?
recv message from client:who are you?
recv message from client:who are you?
需要特别注意的是以下两个函数,消息收发函数
int zmq_recv (void *socket, void *buf, size_t len, int flags);
int zmq_send (void *socket, void *buf, size_t len, int flags);
zmq_recv 和 zmq_send 默认都是阻塞的,可以通过flags=ZMQ_DONTWAIT参数来设置为非阻塞模式。 buf 和 len都是靠应用程序来保证的。
对于阻塞模式,zmq_recv的返回值是接收到的字节数,注意如果超过 len,后面的数据将会被截断,但返回值的长度却是原本没有被截掉的长度。 如果错误,或者在非阻塞模式下没有消息,返回-1,并设置 errno。
另外对于zmq发送消息的理解可参考以下文章:https://dongshao.blog.csdn.net/article/details/105991716
下面给出Python代码,就不做详细解释了
客户端:
import zmq
context = zmq.Context()
socket = context.socket(zmq.REP)
socket.connect('tcp://127.0.0.1:5555')
while True:
message = socket.recv()
print(message)
response = 'server response!'
socket.send(response.encode())
服务端:
import zmq
context = zmq.Context()
socket = context.socket(zmq.REQ)
socket.bind('tcp://*:5555')
while True:
data = input('input your data:')
socket.send(data.encode())
response = socket.recv()
print(response)
PUB-SUB套接字组合是异步的。客户端在一个循环体中使用recv ()接收消息,如果向SUB套接字发送消息则会报错;类似地,服务端可以不断地使用send ()发送消息,但不能再PUB套接字上使用recv ()
下面给出一个用C代码写的PUB端,即主动产生消息的一方,PYTHON写的SUB端,取消息的一方
消息生产方PUB
#include
#include
#include
#include
#include
#include
#include
// 随机生成0...num-1的随机数
#define randof(num) (int) ((float) (num) * random () / (RAND_MAX + 1.0))
// 将string消息格式化为zmq_meg_t对象, 然后发往socket套接字上
static int s_send(void *socket, char *string);
int main()
{
// 1.初始化上下文
void *context = zmq_ctx_new();
// 2.创建、绑定套接字
void *publisher = zmq_socket(context, ZMQ_PUB);
assert(publisher != NULL);
// 此处我们将发布者绑定到一个tcp节点上和一个ipc节点上, 但是本案例我们只使用tcp, ipc那个只是演示说明zmq的套接字可以绑定到多个节点上
int rc = zmq_bind(publisher, "tcp://*:5555");
assert(rc == 0);
// 3.初始化随机数发生器
srandom((unsigned)time(NULL));
// 4.循环发送数据
while(1)
{
// 5.随机生成邮政编码、温度、适度
int zipcode, temperature, relhumidity;
zipcode = randof(100000);
temperature = randof(215) - 80;
relhumidity = randof(50) + 10;
// 6.将消息发送给所有的订阅者
char update[20];
sprintf(update, "%05d %d %d", zipcode, temperature, relhumidity);
rc = s_send(publisher, update);
assert(rc);
sleep(1);
}
// 7.关闭套接字、销毁上下文
zmq_close(publisher);
zmq_ctx_destroy(context);
return 0;
}
static int s_send(void *socket, char *string)
{
// 初始化一个zmq_msg_t对象, 分配的大小为string的大小
zmq_msg_t msg;
zmq_msg_init_size(&msg, strlen(string));
memcpy(zmq_msg_data(&msg), string, strlen(string));
// 发送数据
printf("send data! %s\n",msg);
int rc = zmq_msg_send(&msg, socket, 0);
// 关闭zmq_msg_t对象
zmq_msg_close(&msg);
return rc;
}
消息消费端SUB
import zmq
context = zmq.Context()
socket = context.socket(zmq.SUB)
socket.connect('tcp://127.0.0.1:5555')
socket.setsockopt(zmq.SUBSCRIBE, ''.encode())
while True:
data = socket.recv()
print(data)
需要注意的是:
1,这个模式是单向的,就是说 pub只能发, sub只能收,
2,sub可以注册多个pub,并且多个pub上的消息会公平的过来。
3,如果pub没有任何sub,那么消息将会被丢弃。
4,如果sub消费得比较慢,消息就会堆积在pub端,在v3.x版本里面,tcp 或 ipc的过滤是发生在publisher,而在低版本里面,所有的过滤都是发生在subscriber,这样就比较浪费流量和资源
sub 除了要创建 ZMQ_SUB 类型的socket,并连接之外,还要 调用 zmq_setsockopt (subscriber, ZMQ_SUBSCRIBE,filter, strlen (filter)); 来进行注册,才有效果。 其中filter用来匹配消息开头的字符串,如果匹配则接受下来,否则丢弃;但如果filter = NULL,并且长度为0的话,则表示所有的消息都接收。
publisher的第一个包经常是会被丢掉的,即便 sub端先起来,然后启动push 发送消息,刚开始的消息也有可能丢的 。因为即便是再快的网络,建立连接都是需要一些时间的,比如几个毫秒,而用zmq发送速度太快,在订阅者尚未与发布者建立联系时,已经开始了数据发布(内部局域网没这么夸张的),再结合之前说的如果publisher没有任何subscriber连上来的话消息会被丢弃。官网给了两个解决方案;1, 让发布者先不发数据,而是等订阅者真正连上之后,再发数据; 2,就是发布是永不停止的,没有开始与尽头的概念。