ZeroMQ基础入门

小咪咪 2022-09-04 11:42 193阅读 0赞

mq是消息队列（**message queue**）的简称，目前有多种消息队列可用，包括RabbitMQ、Kafka等，它们各有特色，可以结合具体的项目需求使用。

ZeroMQ简称Zmq，或者0mq，核心引擎由c++编写，是**轻量级消息通信库**，在**对传统的标准socket接口扩展**的基础上形成的特色消息通信中间件。

Zmq提供了**异步消息队列**的抽象，具有多种消息通信模式，能够实现**消息过滤**，能够无缝对接多种传输协议。

**简言之，使用socket时，需要显式地建立连接、销毁连接、选择协议（TCP/UDP）和处理错误等，而ZMQ屏 蔽了这些细节，让网络编程更简单。**

ZeroMQ是网络通信中新的一层，**介于应用层和传输层之间（按照TCP/IP划分）**，是一个可伸缩层，可并行运行，分散在分布式系统间。

总之，下面摘自100字描述：

> ZMQ（ØMQ、ZeroMQ, 0MQ）看起来像是一套嵌入式的网络链接库，但工作起来更像是一个并发式的框架。它提供的套接字可以在多种协议中传输消息，如**线程间、进程间、TCP、广播**等。你可以使用套接字构建多对多的连接模式，如**扇出、发布-订阅、任务分发、请求-应答**等。ZMQ的快速足以胜任集群应用产品。它的异步I/O机制让你能够构建多核应用程序，完成异步消息处理任务。ZMQ有着多语言支持，并能在几乎所有的操作系统上运行。

ZMQ是iMatix公司的产品，以LGPLv3开源协议发布。

--------------------

ZMQ有多种模式可以使用，常用的模式包括request/reply，publish/subscribe，push/pull三种。

## **1. request-reply（请求/应答）** ##

将**一组服务端和一组客户端**相连，用于**远程过程调用或任务分发**。

这里使用请求-应答模式实现一个简单的hello world程序。

和普通的socket通信一样，需要一个客户端和一个服务器。客户端发送hello，服务器收到hello后回应world，如图所示。

![req/rep][req_rep]

服务器代码：

//
    //  Hello World server in C++
    //  Binds REP socket to tcp://*:5555
    //  Expects "Hello" from client, replies with "World"
    //
    #include <zmq.hpp>
    #include <string>
    #include <iostream>
    #ifndef _WIN32
    #include <unistd.h>
    #else
    #include <windows.h>
    
    #define sleep(n)    Sleep(n)
    #endif
    
    int main () {
        //  Prepare our context and socket
        zmq::context_t context (1);
        zmq::socket_t socket (context, ZMQ_REP);
        socket.bind ("tcp://*:5555");
    
        while (true) {
            zmq::message_t request;
            //  Wait for next request from client
            socket.recv (&request);
            std::cout << "Received Hello" << std::endl;
            //  Do some 'work'
            sleep(1);
            //  Send reply back to client
            zmq::message_t reply (5);
            memcpy (reply.data (), "World", 5);
            socket.send (reply);
        }
        return 0;
    }

客户端代码：

//
    //  Hello World client in C++
    //  Connects REQ socket to tcp://localhost:5555
    //  Sends "Hello" to server, expects "World" back
    //
    #include <zmq.hpp>
    #include <string>
    #include <iostream>
    
    int main ()
    {
        //  Prepare our context and socket
        zmq::context_t context (1);
        zmq::socket_t socket (context, ZMQ_REQ);
    
        std::cout << "Connecting to hello world server…" << std::endl;
        socket.connect ("tcp://localhost:5555");
    
        //  Do 10 requests, waiting each time for a response
        for (int request_nbr = 0; request_nbr != 10; request_nbr++) {
            zmq::message_t request (5);
            memcpy (request.data (), "Hello", 5);
            std::cout << "Sending Hello " << request_nbr << "…" << std::endl;
            socket.send (request);
    
            //  Get the reply.
            zmq::message_t reply;
            socket.recv (&reply);
            std::cout << "Received World " << request_nbr << std::endl;
        }
        return 0;
    }

使用REQ-REP套接字发送和接受消息是需要遵循一定规律的。**客户端首先使用zmq\_send()发送消息，再用zmq\_recv()接收**，如此循环。如果打乱了这个顺序（如连续发送两次）则会报错。类似地，**服务端必须先进行接收，后进行发送**。（和http请求的模式一样，请求响应，一次请求对应一个响应）

理论上你可以连接千万个客户端到这个服务端上，同时连接都没问题，程序仍会运作得很好。你可以尝试一下先打开客户端，再打开服务端，可以看到程序仍然会正常工作。

对于字符串，需要注意的一点是，ZMQ不会关心发送消息的内容，只要知道它所包含的字节数。这意味着，**ZMQ的字符串是有长度的，且传送时不加结束符**。当使用c语言接收时，应注意申请比长度多一个字节的存储空间，并置位结束符’/0’，否则在打印字符串时可能得到奇怪的结果。

下面是一个使用c语言处理字符串的例子：

// 从ZMQ套接字中接收字符串，并转换为C语言的字符串
    static char *
    s_recv (void *socket) {
        zmq_msg_t message;
        zmq_msg_init (&message);
        zmq_recv (socket, &message, 0);
        int size = zmq_msg_size (&message);
        char *string = malloc (size + 1);//release it after use
        memcpy (string, zmq_msg_data (&message), size);
        zmq_msg_close (&message);
        string [size] = 0;
        return (string);
    }

## **2. publish/subscribe（发布/订阅）** ##

将一组发布者和一组订阅者相连，用于**数据分发**。

发布/订阅模式实现了**单向数据分发**，服务端将事件发送给一组客户端。

![pub/sub][pub_sub]

让我们看一个天气信息发布的例子，包括邮编、温度、相对湿度。我们生成这些随机信息，用来模拟气象站所做的那样。

服务端代码：

//  Weather update server in C++
    //  Binds PUB socket to tcp://*:5556
    //  Publishes random weather updates
    //
    //  Olivier Chamoux <olivier.chamoux@fr.thalesgroup.com>
    //
    #include <zmq.hpp>
    #include <stdio.h>
    #include <stdlib.h>
    #include <time.h>
    
    #if (defined (WIN32))
    #include <zhelpers.hpp>
    #endif
    
    #define within(num) (int) ((float) num * random () / (RAND_MAX + 1.0))
    
    int main () {
    
        //  Prepare our context and publisher
        zmq::context_t context (1);
        zmq::socket_t publisher (context, ZMQ_PUB);
        publisher.bind("tcp://*:5556");
        publisher.bind("ipc://weather.ipc");                // Not usable on Windows.
    
        //  Initialize random number generator
        srandom ((unsigned) time (NULL));
        while (1) {
    
            int zipcode, temperature, relhumidity;
    
            //  Get values that will fool the boss
            zipcode     = within (100000);
            temperature = within (215) - 80;
            relhumidity = within (50) + 10;
    
            //  Send message to all subscribers
            zmq::message_t message(20);
            snprintf ((char *) message.data(), 20 ,
                "%05d %d %d", zipcode, temperature, relhumidity);
            publisher.send(message);
    
        }
        return 0;
    }

服务端在一个无限循环里更新数据，并把天气信息持续不断地发布出去。注意，它不关心是否有人接收数据，只管发送。如果没有任何人接收数据，它只是简单地丢弃消息。

客户端代码：

//  Weather update client in C++
    //  Connects SUB socket to tcp://localhost:5556
    //  Collects weather updates and finds avg temp in zipcode
    //
    //  Olivier Chamoux <olivier.chamoux@fr.thalesgroup.com>
    #include <zmq.hpp>
    #include <iostream>
    #include <sstream>
    
    int main (int argc, char *argv[])
    {
        zmq::context_t context (1);
    
        //  Socket to talk to server
        std::cout << "Collecting updates from weather server…\n" << std::endl;
        zmq::socket_t subscriber (context, ZMQ_SUB);
        subscriber.connect("tcp://localhost:5556");
    
        //  Subscribe to zipcode, default is NYC, 10001
        const char *filter = (argc > 1)? argv [1]: "10001 ";
        subscriber.setsockopt(ZMQ_SUBSCRIBE, filter, strlen (filter));
    
        //  Process 100 updates
        int update_nbr;
        long total_temp = 0;
        for (update_nbr = 0; update_nbr < 100; update_nbr++) {
    
            zmq::message_t update;
            int zipcode, temperature, relhumidity;
    
            subscriber.recv(&update);
    
            std::istringstream iss(static_cast<char*>(update.data()));
            iss >> zipcode >> temperature >> relhumidity ;
    
            total_temp += temperature;
        }
        std::cout     << "Average temperature for zipcode '"<< filter
                    <<"' was "<<(int) (total_temp / update_nbr) <<"F"
                    << std::endl;
        return 0;
    }

客户端可以根据自己的需要随意订阅感兴趣的数据，它会接受发布者的消息，只处理特定邮编标注的信息，如纽约的邮编是10001。

需要注意的是，**在使用SUB套接字时，必须使用setsockopt()方法来设置订阅的内容**。如果你不设置订阅内容，那将什么消息都收不到（订阅任何主题（An empty 'option\_value' of length zero shall subscribe to all incoming messages））。订阅信息可以是任何字符串，可以设置多次。只要消息满足其中一条订阅信息，SUB套接字就会收到。订阅者可以选择不接收某类消息，也是通过zmq\_setsockopt()方法实现的。

PUB-SUB套接字组合是**异步**的。客户端在一个循环体中使用zmq\_recv()接收消息，如果向SUB套接字发送消息则会报错；类似地，服务端可以不断地使用zmq\_send()发送消息，但不能在**PUB套接字**上使用zmq\_recv()。

关于PUB-SUB套接字，还有一点需要注意：你无法得知SUB是何时开始接收消息的。就算你先打开了SUB套接字，后打开PUB发送消息，这时SUB还是会丢失一些消息的，因为建立连接是需要一些时间的。很少，但并不是零。

关于如何使发布者和订阅者同步，只有当订阅者准备好时发布者才会开始发送消息的方法可以深入研究，有一种简单的方法来同步PUB和SUB，就是让PUB延迟一段时间再发送消息。现实编程中不建议使用这种方式，因为它太脆弱了，而且不好控制。

另一种同步的方式则是认为发布者的消息流是无穷无尽的，因此丢失了前面一部分信息也没有关系。我们的气象信息客户端就是这么做的。

几点说明：

*  订阅者可以连接多个发布者，轮流接收消息；
 *  **如果发布者没有订阅者与之相连，那它发送的消息将直接被丢弃**；
 *  如果你使用TCP协议，那当订阅者处理速度过慢时，消息会在发布者处堆积。可以使用阈值（HWM）来保护发布者。
 *  **从ZeroMQ v3.x开始，当使用(tcp:// or ipc://)连接协议时，消息的过滤在发布端**，使用epgm://时，在订阅端过滤。在ZeroMQ v2.x中，所有消息的过滤是在订阅者处进行的。也就是说，发布者会向订阅者发送所有的消息，订阅者会将未订阅的消息丢弃。

## **3. push/pull（推/拉）** ##

使用扇入或扇出的形式组装多个节点，可以产生多个步骤或循环，用于构建并行处理架构。

zmq的并行处理模型可以进行超级计算：

*  任务分发器会生成大量可以并行计算的任务
 *  有一组worker会处理这些任务，现实中，worker可能散落在不同的计算机中，利用GPU（图像处理单元）进行复杂计算
 *  结果收集器会在末端接收所有worker的处理结果，进行汇总

这就是zmq的推拉模式。

![push/pull][push_pull]

下面是任务分发器的代码，它会生成100个任务，任务内容是让收到的worker延迟若干毫秒。

//  Task ventilator in C++
    //  Binds PUSH socket to tcp://localhost:5557
    //  Sends batch of tasks to workers via that socket
    //
    //  Olivier Chamoux <olivier.chamoux@fr.thalesgroup.com>
    //
    #include <zmq.hpp>
    #include <stdlib.h>
    #include <stdio.h>
    #include <unistd.h>
    #include <iostream>
    
    #define within(num) (int) ((float) num * random () / (RAND_MAX + 1.0))
    
    int main (int argc, char *argv[])
    {
        zmq::context_t context (1);
    
        //  Socket to send messages on
        zmq::socket_t  sender(context, ZMQ_PUSH);
        sender.bind("tcp://*:5557");
    
        std::cout << "Press Enter when the workers are ready: " << std::endl;
        getchar ();
        std::cout << "Sending tasks to workers…\n" << std::endl;
    
        //  The first message is "0" and signals start of batch
        zmq::socket_t sink(context, ZMQ_PUSH);
        sink.connect("tcp://localhost:5558");
        zmq::message_t message(2);
        memcpy(message.data(), "0", 1);
        sink.send(message);
    
        //  Initialize random number generator
        srandom ((unsigned) time (NULL));
    
        //  Send 100 tasks
        int task_nbr;
        int total_msec = 0;     //  Total expected cost in msecs
        for (task_nbr = 0; task_nbr < 100; task_nbr++) {
            int workload;
            //  Random workload from 1 to 100msecs
            workload = within (100) + 1;
            total_msec += workload;
    
            message.rebuild(10);
            memset(message.data(), '\0', 10);
            sprintf ((char *) message.data(), "%d", workload);
            sender.send(message);
        }
        std::cout << "Total expected cost: " << total_msec << " msec" << std::endl;
        sleep (1);              //  Give 0MQ time to deliver
    
        return 0;
    }

下面是worker的代码，它接受信息并延迟指定的毫秒数，并发送执行完毕的信号：

//  Task worker in C++
    //  Connects PULL socket to tcp://localhost:5557
    //  Collects workloads from ventilator via that socket
    //  Connects PUSH socket to tcp://localhost:5558
    //  Sends results to sink via that socket
    //
    //  Olivier Chamoux <>
    //
    
    #include "zhelpers.hpp"
    #include <string>
    
    int main (int argc, char *argv[])
    {
        zmq::context_t context(1);
    
        //  Socket to receive messages on
        zmq::socket_t receiver(context, ZMQ_PULL);
        receiver.connect("tcp://localhost:5557");
    
        //  Socket to send messages to
        zmq::socket_t sender(context, ZMQ_PUSH);
        sender.connect("tcp://localhost:5558");
    
        //  Process tasks forever
        while (1) {
    
            zmq::message_t message;
            int workload;           //  Workload in msecs
    
            receiver.recv(&message);
            std::string smessage(static_cast<char*>(message.data()), message.size());
    
            std::istringstream iss(smessage);
            iss >> workload;
    
            //  Do the work
            s_sleep(workload);
    
            //  Send results to sink
            message.rebuild();
            sender.send(message);
    
            //  Simple progress indicator for the viewer
            std::cout << "." << std::flush;
        }
        return 0;
    }

下面是结果收集器的代码。它会收集100个处理结果，并计算总的执行时间，让我们由此判别任务是否是并行计算的。

//  Task sink in C++
    //  Binds PULL socket to tcp://localhost:5558
    //  Collects results from workers via that socket
    //
    //  Olivier Chamoux <olivier.chamoux@fr.thalesgroup.com>
    //
    #include <zmq.hpp>
    #include <time.h>
    #include <sys/time.h>
    #include <iostream>
    
    int main (int argc, char *argv[])
    {
        //  Prepare our context and socket
        zmq::context_t context(1);
        zmq::socket_t receiver(context,ZMQ_PULL);
        receiver.bind("tcp://*:5558");
    
        //  Wait for start of batch
        zmq::message_t message;
        receiver.recv(&message);
    
        //  Start our clock now
        struct timeval tstart;
        gettimeofday (&tstart, NULL);
    
        //  Process 100 confirmations
        int task_nbr;
        int total_msec = 0;     //  Total calculated cost in msecs
        for (task_nbr = 0; task_nbr < 100; task_nbr++) {
    
            receiver.recv(&message);
            if ((task_nbr / 10) * 10 == task_nbr)
                std::cout << ":" << std::flush;
            else
                std::cout << "." << std::flush;
        }
        //  Calculate and report duration of batch
        struct timeval tend, tdiff;
        gettimeofday (&tend, NULL);
    
        if (tend.tv_usec < tstart.tv_usec) {
            tdiff.tv_sec = tend.tv_sec - tstart.tv_sec - 1;
            tdiff.tv_usec = 1000000 + tend.tv_usec - tstart.tv_usec;
        }
        else {
            tdiff.tv_sec = tend.tv_sec - tstart.tv_sec;
            tdiff.tv_usec = tend.tv_usec - tstart.tv_usec;
        }
        total_msec = tdiff.tv_sec * 1000 + tdiff.tv_usec / 1000;
        std::cout << "\nTotal elapsed time: " << total_msec << " msec\n" << std::endl;
        return 0;
    }

一组任务的平均执行时间在5秒左右，以下是分别开始1个、2个、4个worker时的执行结果：

#   1 worker
    Total elapsed time: 5034 msec
    #   2 workers
    Total elapsed time: 2421 msec
    #   4 workers
    Total elapsed time: 1018 msec

注意事项：

*  worker上游和任务分发器相连，下游和结果收集器相连，这就意味着你可以开启任意多个worker。但若worker是绑定至端点的，而非连接至端点，那我们就需要准备更多的端点，并配置任务分发器和结果收集器。所以说，任务分发器和结果收集器是这个网络结构中较为稳定的部分，因此应该由它们绑定至端点，而非worker，因为它们较为动态。
 *  我们需要做一些同步的工作，等待worker全部启动之后再分发任务。这点在ZMQ中很重要，且不易解决。连接套接字的动作会耗费一定的时间，因此当第一个worker连接成功时，它会一下收到很多任务。所以说，如果我们不进行同步，那这些任务根本就不会被并行地执行。你可以自己试验一下。
 *  任务分发器使用PUSH套接字向worker均匀地分发任务（假设所有的worker都已经连接上了），这种机制称为**负载均衡**
 *  结果收集器的PULL套接字会均匀地从worker处收集消息，这种机制称为**公平队列**

[req_rep]: /images/20220829/84a6078769cd4db582ede0d01475648e.png
[pub_sub]: /images/20220829/a764f42032374d7d96bb3bcfda3f6b0d.png
[push_pull]: /images/20220829/35e712614b0d469b92117a5d4c26fada.png