Zeromq基本模型

Zeromq基本模型

 

http://www.searchtb.com/2012/08/zeromq-primer.html

http://www.kuqin.com/algorithm/20120813/328769.html

1.Request-reply模式

 

说明：步调一致的同步请求应答模式，发送request之后必须等待reply才能继续发送request；

Client端 一般先send request 后 receive reply；

server端 一般先 receive request后 send reply。

该模式的简单使用例程 流程如下：

Start Start

 

 

Client send the request

Server receive the request

Client receive the answer

Server send the answer

 

 

 

 

 

 

 

End End

 

 

 

a) 服务端和客户端无论谁先启动，效果是相同的，这点不同于Socket。

b) 在服务端收到信息以前，程序是阻塞的，会一直等待客户端连接上来。

c) 服务端收到信息以后，会send一个“World”给客户端。值得注意的是一定是client连接上来以后，send消息给Server，然后Server再rev然后响应client，这种一问一答式的。如果Server先send，client先rev是会报错的。

 

// Hello World server

// Binds REP socket to tcp://*:5555

// Expects "Hello" from client, replies with "World"

//

#include

#include

#include

#include

 

int main (void)

{

void *context = zmq_ctx_new ();

 

// Socket to talk to clients

void *responder = zmq_socket (context, ZMQ_REP);

zmq_bind (responder, "tcp://*:5555");

 

while (true) {

// Wait for next request from client,

//do the zmq_msg_recv before zmq_msg_send

zmq_msg_t request;

zmq_msg_init (&request);

//Receiving "Hello" from client through the responder

zmq_msg_recv (&request, responder, 0);

zmq_msg_close (&request);

 

// Do some 'work'

sleep (1);

 

// Send reply back to client

zmq_msg_t reply;

zmq_msg_init_size (&reply, 5);

memcpy (zmq_msg_data (&reply), "World", 5);

// Send "world" to the client through responder

zmq_msg_send (&reply, responder, 0);

zmq_msg_close (&reply);

}

// We never get here but if we did, this would be how we end

zmq_close (responder);

zmq_ctx_destroy (context);

return 0;

}

 

 

//

// Hello World client

// Connects REQ socket to tcp://localhost:5555

// Sends "Hello" to server, expects "World" back

//

#include

#include

#include

#include

int main (void)

{

void *context = zmq_ctx_new ();

 

// Socket to talk to server

printf ("Connecting to hello world server…\n");

void *requester = zmq_socket (context, ZMQ_REQ);

zmq_connect (requester, "tcp://localhost:5555");

 

//only send one rquest an one reply in each process

zmq_msg_t request;

zmq_msg_init_size (&request, 5);

memcpy (zmq_msg_data (&request), "Hello", 5);

printf ("Sending Hello %d…\n", request_nbr);

zmq_msg_send (&request, requester, 0);

zmq_msg_close (&request);

 

zmq_msg_t reply;

zmq_msg_init (&reply);

zmq_msg_recv (&reply, requester, 0);

printf ("Received World %d\n", request_nbr);

zmq_msg_close (&reply);

 

zmq_close (requester);

zmq_ctx_destroy (context);

return 0;

}

 

 

 

 

 

 

 

 

2.Publish-subscribe模式

我们可以想象一下天气预报的订阅模式，由一个节点提供信息源，由其他的节点，接受信息源的信息.

 

 

 

说明：pub-sub是一种异步模型；

publisher向所有的subscriber push所有消息；

subscriber可以订阅多种消息，可以收到任何匹配的消息，可以过滤消息，可以向多个publisher订阅消息。

如果一个publisher没有相关的subscriber，则它只会简单的丢弃消息。

这个模型里，发布端是单向只发送数据的，且不关心是否把全部的信息都发送给订阅端。如果发布端开始发布信息的时候，订阅端尚未连接上来，这些信息直接丢弃。不过一旦订阅端连接上来，中间会保证没有信息丢失。同样，订阅端则只负责接收，而不能反馈。如果发布端和订阅端需要交互（比如要确认订阅者是否已经连接上），则使用额外的 socket 采用请求回应模型满足这个需求

 

 

 

 

 

 

 

 

 

 

 

 

// // Weather update server // Binds PUB socket to tcp://*:5556 // Publishes random weather updates // #include "zhelpers.h"

int main (void) { // Prepare our context and publisher void *context = zmq_ctx_new (); void *publisher = zmq_socket (context, ZMQ_PUB); zmq_bind (publisher, "tcp://*:5556"); zmq_bind (publisher, "ipc://weather.ipc");

// Initialize random number generator srandom ((unsigned) time (NULL)); while (true) { // Get values that will fool the boss int zipcode, temperature, relhumidity; zipcode = randof (100000); temperature = randof (215) - 80; relhumidity = randof (50) + 10;

// Send message to all subscribers char update [20]; sprintf (update, "d %d %d", zipcode, temperature, relhumidity); s_send (publisher, update); } zmq_close (publisher); zmq_ctx_destroy (context); return 0; }

// Weather update client // Connects SUB socket to tcp://localhost:5556 // Collects weather updates and finds avg temp in zipcode #include "zhelpers.h"

int main (int argc, char *argv []) { void *context = zmq_ctx_new ();

// Socket to talk to server printf ("Collecting updates from weather server…\n"); void *subscriber = zmq_socket (context, ZMQ_SUB); zmq_connect (subscriber, "tcp://localhost:5556");

// Subscribe to zipcode, default is NYC, 10001 char *filter = (argc > 1)? argv [1]: "10001 "; zmq_setsockopt (subscriber, ZMQ_SUBSCRIBE, filter, strlen (filter)); char *string = s_recv (subscriber);

int zipcode, temperature, relhumidity; sscanf (string, "%d %d %d",&zipcode, &temperature, &relhumidity);
printf ("the imformation for zipcode '%s' was %d %d %d \n", filter,zipcode,temperature,relhumidity);

zmq_close (subscriber); zmq_ctx_destroy (context); return 0; }

a) 客户端需要zmq_setsockopt (subscriber, ZMQ_SUBSCRIBE, filter, strlen (filter));设置一个过滤值，相当于设定一个订阅频道，否则什么信息也收不到。

b) 服务器端一直不断的广播中，如果中途有Subscriber端退出，并不影响他继续的广播，当Subscriber再连接上来的时候，收到的就是后来发送的新的信息了。这对比较晚加入的，或者是中途离开的订阅者，必然会丢失掉一部分信息.

c) 但是，如果Publisher中途离开，所有的Subscriber会hold住，等待Publisher再上线的时候，会继续接受信息。

3.Pipeline即 push-pull模式

想象一下这样的场景，如果需要统计各个机器的日志，我们需要将统计任务分发到各个节点机器上，最后收集统计结果，做一个汇总。PipeLine比较适合于这种场景.

 

 

 

说明：这个模型里，管道是单向的，从 PUSH 端单向的向 PULL 端单向的推送数据流；

Ventilator将任务分配给worker实现任务的并行处理；

Push-pull模式是单向的，很适合消费者能力不足的情况，可以提供多个消费者。一条消息如果被A消费，B将不会再消费这条消息。

 

可以看到，task ventilator使用的是SOCKET_PUSH，将任务分发到Worker节点上。而Worker节点上，使用SOCKET_PULL从上游接受任务，并使用SOCKET_PUSH将结果汇集到Slink。值得注意的是，任务的分发的时候也同样有一个负载均衡的路由功能，worker可以随时自由加入，task ventilator可以均衡将任务分发出去