一、我们为什么需要 ZMQ
目前的应用程序很多都会包含跨网络的组件，无论是局域网还是因特网。这些程序的开发者都会用到某种消息通信机制。有些人会使用某种消息队列产品，而大多数人则会自己手工来做这些事，使用 TCP 或 UDP 协议。这些协议使用起来并不困难，但是，简单地将消息从 A 发给 B，和在任何情况下都能进行可靠的消息传输，这两种情况显然是不同的。
首先看看在使用纯 TCP 协议进行消息传输时会遇到的一些典型问题。任何可复用的消息传输层肯定或多或少地会要解决以下问题：
如何处理 I/O？是让程序阻塞等待响应，还是在后台处理这些事？这是软件设计的关键因素。阻塞式的 I/O 操作会让程序架构难以扩展，而后台处理 I/O 也是比较困难的。
如何处理那些临时的、来去自由的组件？我们是否要将组件分为客户端和服务端两种，并要求服务端永不消失？那如果我们想要将服务端相连怎么办？我们要每隔几秒就进行重连吗？
如何表示一条消息？我们怎样通过拆分消息，让其变得易读易写，不用担心缓存溢出，既能高效地传输小消息，又能胜任视频等大型文件的传输？
如何处理那些不能立刻发送出去的消息？比如我们需要等待一个网络组件重新连接的时候？我们是直接丢弃该条消息，还是将它存入数据库，或是内存中的一个队列？
要在哪里保存消息队列？如果某个组件读取消息队列的速度很慢，造成消息的堆积怎么办？我们要采取什么样的策略？
如何处理丢失的消息？我们是等待新的数据，请求重发，还是需要建立一套新的可靠性机制以保证消息不会丢失？如果这个机制自身崩溃了呢？
如果想换一种网络连接协议，如用广播代替 TCP 单播？或者改用 IPv6？我们是否需要重写所有的应用程序，或者将这种协议抽象到一个单独的层中？
如何对消息进行路由？我们可以将消息同时发送给多个节点吗？是否能将应答消息返回给请求的发送方？
如何为另一种语言写一个 API？我们是否需要完全重写某项协议，还是重新打包一个类库？
怎样才能做到在不同的架构之间传送消息？是否需要为消息规定一种编码？
如何处理网络通信错误？等待并重试，还是直接忽略或取消？
ZMQ 就是这样一种软件：它高效，提供了嵌入式的类库，使应用程序能够很好地在网络中扩展，成本低廉。
ZMQ 的主要特点有：
ZMQ 会在后台线程异步地处理 I/O 操作，它使用一种不会死锁的数据结构来存储消息。
网络组件可以来去自如，ZMQ 会负责自动重连，这就意味着你可以以任何顺序启动组件；用它创建的面向服务架构（SOA）中，服务端可以随意地加入或退出网络。
ZMQ 会在有必要的情况下自动将消息放入队列中保存，一旦建立了连接就开始发送。
ZMQ 有阈值（HWM）的机制，可以避免消息溢出。当队列已满，ZMQ 会自动阻塞发送者，或丢弃部分消息，这些行为取决于你所使用的消息模式。
ZMQ 可以让你用不同的通信协议进行连接，如 TCP、广播、进程内、进程间。改变通信协议时你不需要去修改代码。
ZMQ 会恰当地处理速度较慢的节点，会根据消息模式使用不同的策略。
ZMQ 提供了多种模式进行消息路由，如请求-应答模式、发布-订阅模式等。这些模式可以用来搭建网络拓扑结构。
ZMQ 中可以根据消息模式建立起一些中间装置（很小巧），可以用来降低网络的复杂程度。
ZMQ 会发送整个消息，使用消息帧的机制来传递。如果你发送了 10KB 大小的消息，你就会收到 10KB 大小的消息。
ZMQ 不强制使用某种消息格式，消息可以是 0 字节的，或是大到 GB 级的数据。当你表示这些消息时，可以选用诸如谷歌的 protocol buffers，XDR 等序列化产品。
ZMQ 能够智能地处理网络错误，有时它会进行重试，有时会告知你某项操作发生了错误。
ZMQ 甚至可以降低对环境的污染，因为节省了 CPU 时间意味着节省了电能。
其实 ZMQ 可以做的还不止这些，它会颠覆人们编写网络应用程序的模式。虽然从表面上看，它不过是提供了一套处理套接字的 API，能够用 zmq_recv()和 zmq_send()进行消息的收发，但是，消息处理将成为应用程序的核心部分，很快你的程序就会变成一个个消息处理模块，这既美观又自然。它的扩展性还很强，每项任务由一个节点（节点是一个线程）、同一台机器上的两个节点（节点是一个进程）、同一网络上的两台机器（节点是一台机器）来处理，而不需要改动应用程序。
二、ZeroMQ 背景介绍
官方：“ZMQ(以下 ZeroMQ 简称 ZMQ)是一个简单好用的传输层，像框架一样的一个 socket library，他使得 Socket 编程更加简单、简洁和性能更高。是一个消息处理队列库，可在多个线程、内核和主机盒之间弹性伸缩。
ZMQ 的明确目标是“成为标准网络协议栈的一部分，之后进入 Linux 内核”。现在还未看到它们的成功。但是，它无疑是极具前景的、并且是人们更加需要的“传统”BSD 套接字之上的一层封装。ZMQ 让编写高性能网络应用程序极为简单和有趣。”
与其他消息中间件相比，ZMQ 并不像是一个传统意义上的消息队列服务器，事实上，它也根本不是一个服务器，它更像是一个底层的网络通讯库，在 Socket API 之上做了一层封装，将网络通讯、进程通讯和线程通讯抽象为统一的 API 接口。
三、ZMQ 是什么
阅读了 ZMQ 的 Guide 文档后，这是个类似于 Socket 的一系列接口，他跟 Socket 的区别是：普通的 socket 是端到端的（1:1 的关系），而 ZMQ 却是可以 N：M 的关系，人们对 BSD 套接字的了解较多的是点对点的连接，点对点连接需要显式地建立连接、销毁连接、选择协议（TCP/UDP）和处理错误等，而 ZMQ 屏蔽了这些细节，让你的网络编程更为简单。ZMQ 用于 node 与 node 间的通信，node 可以是主机或者是进程。
四、三种模型
4.1 应答模式
使用 REQ-REP 套接字发送和接受消息是需要遵循一定规律的。客户端首先使用 zmq_send()发送消息，再用 zmq_recv()接收，如此循环。如果打乱了这个顺序（如连续发送两次）则会报错。类似地，服务端必须先进行接收，后进行发送。
4.2 订阅发布模式
PUB-SUB 套接字组合是异步的。客户端在一个循环体中使用 recv ()接收消息，如果向 SUB 套接字发送消息则会报错；类似地，服务端可以不断地使用 send ()发送消息，但不能在 PUB 套接字上使用 recv ()。
关于 PUB-SUB 套接字，还有一点需要注意：你无法得知 SUB 是何时开始接收消息的。就算你先打开了 SUB 套接字，后打开 PUB 发送消息，这时 SUB 还是会丢失一些消息的，因为建立连接是需要一些时间的。很少，但并不是零。解决此问题需要在 PUB 端加入 sleep。
4.3 基于分布式处理（管道模式）
下面贴出 PUB_SUB(应答模式)模式下的代码：
发布端：
package cn.edu.ujn.pub_sub;
import org.zeromq.ZMQ;
import org.zeromq.ZMQ.Context;
import org.zeromq.ZMQ.Socket; /**
* Pubsub envelope publisher
*/
public class psenvpub {
public static void main (String[] args) throws Exception {
// Prepare our context and publisher
Context context = ZMQ.context(1);
Socket publisher = context.socket(ZMQ.PUB);
publisher.bind("tcp://*:5563");
while (!Thread.currentThread ().isInterrupted ()) {
// Write two messages, each with an envelope and content
publisher.sendMore ("A");
publisher.send ("We don't want to see this");
publisher.sendMore ("B");
publisher.send("We would like to see this");
}
publisher.close ();
context.term ();
}
}
复制代码
发布端需要通过context.socket（ZMQ.PUB）表示为发布端，通过 bind 方法来创建发布端连接，等待订阅者连接。
之后通过 send 方法将数据发送到出去。
之后来写订阅端代码
package cn.edu.ujn.pub_sub;
import org.zeromq.ZMQ;
import org.zeromq.ZMQ.Context;
import org.zeromq.ZMQ.Socket;
/**
* Pubsub envelope subscriber
*/
public class psenvsub {
public static void main (String[] args) {
// Prepare our context and subscriber
Context context = ZMQ.context(1);
Socket subscriber = context.socket(ZMQ.SUB);
subscriber.connect("tcp://localhost:5563");
subscriber.subscribe("B".getBytes());
while (!Thread.currentThread ().isInterrupted ()) {
// Read envelope with address
String address = subscriber.recvStr ();
// Read message contents
String contents = subscriber.recvStr ();
System.out.println(address + " : " + contents);
}
subscriber.close ();
context.term ();
}
}
复制代码
客户端通过 connect 进行连接，之后通过 recv 来进行数据接收。
下面贴出 REQ_REP(订阅发布模式)模式下的代码：
发送端：
package cn.edu.ujn.req_rep;
//
// Hello World server in Java
// Binds REP socket to tcp://*:5555
// Expects "Hello" from client, replies with "World"
//
import org.zeromq.ZMQ;
public class hwserver {
private static int i = 0;
public static void main(String[] args) throws Exception {
ZMQ.Context context = ZMQ.context(1);
// Socket to talk to clients
ZMQ.Socket responder = context.socket(ZMQ.REP);
responder.bind("tcp://*:5555");
while (!Thread.currentThread().isInterrupted()) {
// Wait for next request from the client
byte[] request = responder.recv(0);
System.out.println("Received " + new String(request) + i++);
// Do some 'work'
Thread.sleep(1000);
// Send reply back to client
String reply = "World";
responder.send(reply.getBytes(), 0);
}
responder.close();
context.term();
}
}
复制代码
接收端：
package cn.edu.ujn.req_rep;
// Hello World client in Java
// Connects REQ socket to tcp://localhost:5555
// Sends "Hello" to server, expects "World" back
import org.zeromq.ZMQ;
public class hwclient {
public static void main(String[] args) {
ZMQ.Context context = ZMQ.context(1);
// Socket to talk to server
System.out.println("Connecting to hello world server…");
ZMQ.Socket requester = context.socket(ZMQ.REQ);
requester.connect("tcp://localhost:5555");
for (int requestNbr = 0; requestNbr != 10; requestNbr++) {
String request = "Hello";
System.out.println("Sending Hello " + requestNbr);
requester.send(request.getBytes(), 0);
byte[] reply = requester.recv(0);
System.out.println("Received " + new String(reply) + " " + requestNbr);
}
requester.close();
context.term();
}
}
复制代码
下面贴出 Para_Pipe(基于分布式处理（管道模式）)模式下的代码：
发送端：
package cn.edu.ujn.para_pipe;
import java.util.Random;
import org.zeromq.ZMQ;
// Task ventilator in Java
// Binds PUSH socket to tcp://localhost:5557
// Sends batch of tasks to workers via that socket
public class taskvent {
public static void main (String[] args) throws Exception {
ZMQ.Context context = ZMQ.context(1);
// Socket to send messages on
ZMQ.Socket sender = context.socket(ZMQ.PUSH);
sender.bind("tcp://*:5557");
// Socket to send messages on
ZMQ.Socket sink = context.socket(ZMQ.PUSH);
sink.connect("tcp://localhost:5558");
System.out.println("Press Enter when the workers are ready: ");
System.in.read();
System.out.println("Sending tasks to workers\n");
// The first message is "0" and signals start of batch
sink.send("0", 0);
// Initialize random number generator
Random srandom = new Random(System.currentTimeMillis());
// 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 = srandom.nextInt(100) + 1;
total_msec += workload;
System.out.print(workload + ".");
String string = String.format("%d", workload);
sender.send(string, 0);
}
System.out.println("Total expected cost: " + total_msec + " msec");
Thread.sleep(1000); // Give 0MQ time to deliver
sink.close();
sender.close();
context.term();
}
}
复制代码
中介端：
package cn.edu.ujn.para_pipe;
import org.zeromq.ZMQ;
// Task worker in Java
// 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
public class taskwork {
public static void main (String[] args) throws Exception {
ZMQ.Context context = ZMQ.context(1);
// Socket to receive messages on
ZMQ.Socket receiver = context.socket(ZMQ.PULL);
receiver.connect("tcp://localhost:5557");
// Socket to send messages to
ZMQ.Socket sender = context.socket(ZMQ.PUSH);
sender.connect("tcp://localhost:5558");
// Process tasks forever
while (!Thread.currentThread ().isInterrupted ()) {
String string = new String(receiver.recv(0)).trim();
long msec = Long.parseLong(string);
// Simple progress indicator for the viewer
System.out.flush();
System.out.print(string + '.');
// Do the work
Thread.sleep(msec);
// Send results to sink
sender.send("".getBytes(), 0);
}
sender.close();
receiver.close();
context.term();
}
}
复制代码
接收端：
package cn.edu.ujn.para_pipe;
import org.zeromq.ZMQ;
// Task sink in Java
// Binds PULL socket to tcp://localhost:5558
// Collects results from workers via that socket
public class tasksink {
public static void main (String[] args) throws Exception {
// Prepare our context and socket
ZMQ.Context context = ZMQ.context(1);
ZMQ.Socket receiver = context.socket(ZMQ.PULL);
receiver.bind("tcp://*:5558");
// Wait for start of batch
String string = new String(receiver.recv(0));
// Start our clock now
long tstart = System.currentTimeMillis();
// Process 100 confirmations
int task_nbr;
int total_msec = 0; // Total calculated cost in msecs
for (task_nbr = 0; task_nbr < 100; task_nbr++) {
string = new String(receiver.recv(0)).trim();
if ((task_nbr / 10) * 10 == task_nbr) {
System.out.print(":");
} else {
System.out.print(".");
}
}
// Calculate and report duration of batch
long tend = System.currentTimeMillis();
System.out.println("\nTotal elapsed time: " + (tend - tstart) + " msec");
receiver.close();
context.term();
}
}
复制代码
五、注意事项
5.1 正确地使用上下文
ZMQ 应用程序的一开始总是会先创建一个上下文，并用它来创建套接字。在 C 语言中，创建上下文的函数是 zmq_init()。一个进程中只应该创建一个上下文。从技术的角度来说，上下文是一个容器，包含了该进程下所有的套接字，并为 inproc 协议提供实现，用以高速连接进程内不同的线程。
如果一个进程中创建了两个上下文，那就相当于启动了两个 ZMQ 实例。如果这正是你需要的，那没有问题，但一般情况下：在一个进程中使用 zmq_init()函数创建一个上下文，并在结束时使用 zmq_term()函数关闭它。
如果你使用了 fork()系统调用，那每个进程需要自己的上下文对象。如果在调用 fork()之前调用了 zmq_init()函数，那每个子进程都会有自己的上下文对象。通常情况下，你会需要在子进程中做些有趣的事，而让父进程来管理它们。
5.2 正确地退出和清理
程序员的一个良好习惯是：总是在结束时进行清理工作。当你使用像 Python 那样的语言编写 ZMQ 应用程序时，系统会自动帮你完成清理。但如果使用的是 C 语言，那就需要小心地处理了，否则可能发生内存泄露、应用程序不稳定等问题。
内存泄露只是问题之一，其实 ZMQ 是很在意程序的退出方式的。个中原因比较复杂，但简单的来说，如果仍有套接字处于打开状态，调用 zmq_term()时会导致程序挂起；就算关闭了所有的套接字，如果仍有消息处于待发送状态，zmq_term()也会造成程序的等待。只有当套接字的 LINGER 选项设为 0 时才能避免。
我们需要关注的 ZMQ 对象包括：消息、套接字、上下文。好在内容并不多，至少在一般的应用程序中是这样：
处理完消息后，记得用 zmq_msg_close()函数关闭消息；
如果你同时打开或关闭了很多套接字，那可能需要重新规划一下程序的结构了；
退出程序时，应该先关闭所有的套接字，最后调用 zmq_term()函数，销毁上下文对象。
5.3 你的想法可能会被颠覆
传统网络编程的一个规则是套接字只能和一个节点建立连接。虽然也有广播的协议，但毕竟是第三方的。当我们认定“一个套接字 = 一个连接”的时候，我们会用一些特定的方式来扩展应用程序架构：我们为每一块逻辑创建线程，该线程独立地维护一个套接字。
但在 ZMQ 的世界里，套接字是智能的、多线程的，能够自动地维护一组完整的连接。你无法看到它们，甚至不能直接操纵这些连接。当你进行消息的收发、轮询等操作时，只能和 ZMQ 套接字打交道，而不是连接本身。所以说，ZMQ 世界里的连接是私有的，不对外部开放，这也是 ZMQ 易于扩展的原因之一。
由于你的代码只会和某个套接字进行通信，这样就可以处理任意多个连接，使用任意一种网络协议。而 ZMQ 的消息模式又可以进行更为廉价和便捷的扩展。
这样一来，传统的思维就无法在 ZMQ 的世界里应用了。在你阅读示例程序代码的时候，也许你脑子里会想方设法地将这些代码和传统的网络编程相关联：当你读到“套接字”的时候，会认为它就表示与另一个节点的连接——这种想法是错误的；当你读到“线程”时，会认为它是与另一个节点的连接——这也是错误的。
如果你是第一次阅读本指南，使用 ZMQ 进行了一两天的开发（或者更长），可能会觉得疑惑，ZMQ 怎么会让事情便得如此简单。你再次尝试用以往的思维去理解 ZMQ，但又无功而返。最后，你会被 ZMQ 的理念所折服，拨云见雾，开始享受 ZMQ 带来的乐趣。
评论