轻量级进程间通信ZMQ详解(C&&PYTHON)

目录

一:ZMQ简介

二:ZMQ的request-reply模式

三:ZMQ的pub-sub模式


一:ZMQ简介

        官方介绍: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即可完成进程间的通信。

        下面会根据上述需求给出穿刺代码

二:ZMQ的request-reply模式

轻量级进程间通信ZMQ详解(C&&PYTHON)_第1张图片

         使用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)

三:ZMQ的pub-sub模式

轻量级进程间通信ZMQ详解(C&&PYTHON)_第2张图片

         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,就是发布是永不停止的,没有开始与尽头的概念。

你可能感兴趣的:(Others,zmq,进程间通信,消息队列,python,C)