- 浏览: 469404 次
- 性别:
- 来自: 上海
文章分类
最新评论
-
kc_hxd_jp:
博主问个问题,这个篇幅下的python代码无法达到应有的作用, ...
zeroMQ初体验-14.命名机制 进阶 -
kobe1029:
Map<String, Object> args ...
rabbitmq 队列长度预设的曲线方案 -
Sasoritattoo:
LZ,这都13年了,抽空把这篇文章的下文给表完了吧,这一口气喘 ...
nginx + gridfs + mongodb 大事记(残) -
3GQQ2012:
引用前文已经说过,XREP其实用以平衡负载,所以这里由它对请求 ...
zeroMQ初体验-15.应答模式进阶(一)-数据的封装 -
iyuan:
ustclz 写道图片怎么显示不了了。。我这看是可以显示的。不 ...
zeroMQ初体验-1.简介及C/S模式
服务器:
代码不短,不过作者的牢骚更长。(貌似花了一周的时间)
当然作为一个靠谱的模型,总会制定一些规范给某些不太靠谱的人:http://rfc.zeromq.org/spec:12
至此,整个教程算是告一段落了。(之所以这最后一个模型分了三段,着实是代码多了些)
教程结束了,学习才刚开始。至于会不会再有后续,诚如guide结尾:
More coming soon…
结言:
虽然知道翻译技术文章有难度,但着实还是吓着了,在写第一章的时候就打了退堂鼓。终究在自我安慰、勉励下完成了这个系列的笔记(退一步)。好吧,我承认代码、图示占了大比例,不过,好歹算是有始有终的完成了。
原计划一周时间结束的,由于诸多原因(磨蹭,消极,退堂鼓)前后竟然跨了两个多月,总算咬牙坚持了下来,其实不敢说学到了很多,自从中部python的代码不再时,几乎就没有再自己验证代码的可行和逻辑了。写本系列,更多的是自个儿跟自个儿过不去(俺就不信写不完了!)折腾到最后,多少也是有些收获的(谁折腾谁知道~)
回首看看,也就这样了,倒是有些"天凉好个秋"的意味。
也罢,哦了~
不做响应应当的话,可以要求另起一条线路,订阅者定时向发布端发布存活消息,用以刷新session,其实类似心跳,但是不需要那么高频率,而且是另外用一条线路,便不会出现心跳和数据互相影响的麻烦
原生的是没有这种实现的(第三方实现就不清楚了).zmq的目标是无锁,原子操作,一旦客/服有了回馈机制,理论上来说就完全推翻了zmq的根本,退一步来说,通过中间层来完成这个需求可以却没意义(那还不如直接用rabbitmq之类的自带中间存储/查寻 的队列实现).
总的来说,zmq的应用场景主要是安全性低,速度求快.
对可靠性有要求的话,还是建议换到rabbit之类的中间件
这个真没搞过,原作者搞zmq的一大野心便是能被录入到linux核中,windows的真心没有关注过,不过理论上只要符合amqp协议,应该是没有os绑架的。
ps:用c++写zmq,原作者似乎也有吐槽,正在推倒重来(c),具体可以搜索下,还有就是,珍爱生命,远离windows~
// // Clone server Model Six // // Lets us build this source without creating a library #include "bstar.c" #include "kvmsg.c" // Bstar reactor handlers static int s_snapshots (zloop_t *loop, void *socket, void *args); static int s_collector (zloop_t *loop, void *socket, void *args); static int s_flush_ttl (zloop_t *loop, void *socket, void *args); static int s_send_hugz (zloop_t *loop, void *socket, void *args); static int s_new_master (zloop_t *loop, void *unused, void *args); static int s_new_slave (zloop_t *loop, void *unused, void *args); static int s_subscriber (zloop_t *loop, void *socket, void *args); // Our server is defined by these properties typedef struct { zctx_t *ctx; // Context wrapper zhash_t *kvmap; // Key-value store bstar_t *bstar; // Bstar reactor core int64_t sequence; // How many updates we're at int port; // Main port we're working on int peer; // Main port of our peer void *publisher; // Publish updates and hugz void *collector; // Collect updates from clients void *subscriber; // Get updates from peer zlist_t *pending; // Pending updates from clients Bool primary; // TRUE if we're primary Bool master; // TRUE if we're master Bool slave; // TRUE if we're slave } clonesrv_t; int main (int argc, char *argv []) { clonesrv_t *self = (clonesrv_t *) zmalloc (sizeof (clonesrv_t)); if (argc == 2 && streq (argv [1], "-p")) { zclock_log ("I: primary master, waiting for backup (slave)"); self->bstar = bstar_new (BSTAR_PRIMARY, "tcp://*:5003", "tcp://localhost:5004"); bstar_voter (self->bstar, "tcp://*:5556", ZMQ_ROUTER, s_snapshots, self); self->port = 5556; self->peer = 5566; self->primary = TRUE; } else if (argc == 2 && streq (argv [1], "-b")) { zclock_log ("I: backup slave, waiting for primary (master)"); self->bstar = bstar_new (BSTAR_BACKUP, "tcp://*:5004", "tcp://localhost:5003"); bstar_voter (self->bstar, "tcp://*:5566", ZMQ_ROUTER, s_snapshots, self); self->port = 5566; self->peer = 5556; self->primary = FALSE; } else { printf ("Usage: clonesrv4 { -p | -b }\n"); free (self); exit (0); } // Primary server will become first master if (self->primary) self->kvmap = zhash_new (); self->ctx = zctx_new (); self->pending = zlist_new (); bstar_set_verbose (self->bstar, TRUE); // Set up our clone server sockets self->publisher = zsocket_new (self->ctx, ZMQ_PUB); self->collector = zsocket_new (self->ctx, ZMQ_SUB); zsocket_bind (self->publisher, "tcp://*:%d", self->port + 1); zsocket_bind (self->collector, "tcp://*:%d", self->port + 2); // Set up our own clone client interface to peer self->subscriber = zsocket_new (self->ctx, ZMQ_SUB); zsocket_connect (self->subscriber, "tcp://localhost:%d", self->peer + 1); // Register state change handlers bstar_new_master (self->bstar, s_new_master, self); bstar_new_slave (self->bstar, s_new_slave, self); // Register our other handlers with the bstar reactor zloop_reader (bstar_zloop (self->bstar), self->collector, s_collector, self); zloop_timer (bstar_zloop (self->bstar), 1000, 0, s_flush_ttl, self); zloop_timer (bstar_zloop (self->bstar), 1000, 0, s_send_hugz, self); // Start the Bstar reactor bstar_start (self->bstar); // Interrupted, so shut down while (zlist_size (self->pending)) { kvmsg_t *kvmsg = (kvmsg_t *) zlist_pop (self->pending); kvmsg_destroy (&kvmsg); } zlist_destroy (&self->pending); bstar_destroy (&self->bstar); zhash_destroy (&self->kvmap); zctx_destroy (&self->ctx); free (self); return 0; } // --------------------------------------------------------------------- // Send snapshots to clients who ask for them static int s_send_single (char *key, void *data, void *args); // Routing information for a key-value snapshot typedef struct { void *socket; // ROUTER socket to send to zframe_t *identity; // Identity of peer who requested state char *subtree; // Client subtree specification } kvroute_t; static int s_snapshots (zloop_t *loop, void *snapshot, void *args) { clonesrv_t *self = (clonesrv_t *) args; zframe_t *identity = zframe_recv (snapshot); if (identity) { // Request is in second frame of message char *request = zstr_recv (snapshot); char *subtree = NULL; if (streq (request, "ICANHAZ?")) { free (request); subtree = zstr_recv (snapshot); } else printf ("E: bad request, aborting\n"); if (subtree) { // Send state socket to client kvroute_t routing = { snapshot, identity, subtree }; zhash_foreach (self->kvmap, s_send_single, &routing); // Now send END message with sequence number zclock_log ("I: sending shapshot=%d", (int) self->sequence); zframe_send (&identity, snapshot, ZFRAME_MORE); kvmsg_t *kvmsg = kvmsg_new (self->sequence); kvmsg_set_key (kvmsg, "KTHXBAI"); kvmsg_set_body (kvmsg, (byte *) subtree, 0); kvmsg_send (kvmsg, snapshot); kvmsg_destroy (&kvmsg); free (subtree); } } return 0; } // Send one state snapshot key-value pair to a socket // Hash item data is our kvmsg object, ready to send static int s_send_single (char *key, void *data, void *args) { kvroute_t *kvroute = (kvroute_t *) args; kvmsg_t *kvmsg = (kvmsg_t *) data; if (strlen (kvroute->subtree) <= strlen (kvmsg_key (kvmsg)) && memcmp (kvroute->subtree, kvmsg_key (kvmsg), strlen (kvroute->subtree)) == 0) { // Send identity of recipient first zframe_send (&kvroute->identity, kvroute->socket, ZFRAME_MORE + ZFRAME_REUSE); kvmsg_send (kvmsg, kvroute->socket); } return 0; } // --------------------------------------------------------------------- // Collect updates from clients // If we're master, we apply these to the kvmap // If we're slave, or unsure, we queue them on our pending list static int s_was_pending (clonesrv_t *self, kvmsg_t *kvmsg); static int s_collector (zloop_t *loop, void *collector, void *args) { clonesrv_t *self = (clonesrv_t *) args; kvmsg_t *kvmsg = kvmsg_recv (collector); kvmsg_dump (kvmsg); if (kvmsg) { if (self->master) { kvmsg_set_sequence (kvmsg, ++self->sequence); kvmsg_send (kvmsg, self->publisher); int ttl = atoi (kvmsg_get_prop (kvmsg, "ttl")); if (ttl) kvmsg_set_prop (kvmsg, "ttl", "%" PRId64, zclock_time () + ttl * 1000); kvmsg_store (&kvmsg, self->kvmap); zclock_log ("I: publishing update=%d", (int) self->sequence); } else { // If we already got message from master, drop it, else // hold on pending list if (s_was_pending (self, kvmsg)) kvmsg_destroy (&kvmsg); else zlist_append (self->pending, kvmsg); } } return 0; } // If message was already on pending list, remove it and // return TRUE, else return FALSE. static int s_was_pending (clonesrv_t *self, kvmsg_t *kvmsg) { kvmsg_t *held = (kvmsg_t *) zlist_first (self->pending); while (held) { if (memcmp (kvmsg_uuid (kvmsg), kvmsg_uuid (held), sizeof (uuid_t)) == 0) { zlist_remove (self->pending, held); return TRUE; } held = (kvmsg_t *) zlist_next (self->pending); } return FALSE; } // --------------------------------------------------------------------- // Purge ephemeral values that have expired static int s_flush_single (char *key, void *data, void *args); static int s_flush_ttl (zloop_t *loop, void *unused, void *args) { clonesrv_t *self = (clonesrv_t *) args; zhash_foreach (self->kvmap, s_flush_single, args); return 0; } // If key-value pair has expired, delete it and publish the // fact to listening clients. static int s_flush_single (char *key, void *data, void *args) { clonesrv_t *self = (clonesrv_t *) args; kvmsg_t *kvmsg = (kvmsg_t *) data; int64_t ttl; sscanf (kvmsg_get_prop (kvmsg, "ttl"), "%" PRId64, &ttl); if (ttl && zclock_time () >= ttl) { kvmsg_set_sequence (kvmsg, ++self->sequence); kvmsg_set_body (kvmsg, (byte *) "", 0); kvmsg_send (kvmsg, self->publisher); kvmsg_store (&kvmsg, self->kvmap); zclock_log ("I: publishing delete=%d", (int) self->sequence); } return 0; } // --------------------------------------------------------------------- // Send hugz to anyone listening on the publisher socket static int s_send_hugz (zloop_t *loop, void *unused, void *args) { clonesrv_t *self = (clonesrv_t *) args; kvmsg_t *kvmsg = kvmsg_new (self->sequence); kvmsg_set_key (kvmsg, "HUGZ"); kvmsg_set_body (kvmsg, (byte *) "", 0); kvmsg_send (kvmsg, self->publisher); kvmsg_destroy (&kvmsg); return 0; } // --------------------------------------------------------------------- // State change handlers // We're becoming master // // The backup server applies its pending list to its own hash table, // and then starts to process state snapshot requests. static int s_new_master (zloop_t *loop, void *unused, void *args) { clonesrv_t *self = (clonesrv_t *) args; self->master = TRUE; self->slave = FALSE; zloop_cancel (bstar_zloop (self->bstar), self->subscriber); // Apply pending list to own hash table while (zlist_size (self->pending)) { kvmsg_t *kvmsg = (kvmsg_t *) zlist_pop (self->pending); kvmsg_set_sequence (kvmsg, ++self->sequence); kvmsg_send (kvmsg, self->publisher); kvmsg_store (&kvmsg, self->kvmap); zclock_log ("I: publishing pending=%d", (int) self->sequence); } return 0; } // --------------------------------------------------------------------- // We're becoming slave static int s_new_slave (zloop_t *loop, void *unused, void *args) { clonesrv_t *self = (clonesrv_t *) args; zhash_destroy (&self->kvmap); self->master = FALSE; self->slave = TRUE; zloop_reader (bstar_zloop (self->bstar), self->subscriber, s_subscriber, self); return 0; } // --------------------------------------------------------------------- // Collect updates from peer (master) // We're always slave when we get these updates static int s_subscriber (zloop_t *loop, void *subscriber, void *args) { clonesrv_t *self = (clonesrv_t *) args; // Get state snapshot if necessary if (self->kvmap == NULL) { self->kvmap = zhash_new (); void *snapshot = zsocket_new (self->ctx, ZMQ_DEALER); zsocket_connect (snapshot, "tcp://localhost:%d", self->peer); zclock_log ("I: asking for snapshot from: tcp://localhost:%d", self->peer); zstr_send (snapshot, "ICANHAZ?"); while (TRUE) { kvmsg_t *kvmsg = kvmsg_recv (snapshot); if (!kvmsg) break; // Interrupted if (streq (kvmsg_key (kvmsg), "KTHXBAI")) { self->sequence = kvmsg_sequence (kvmsg); kvmsg_destroy (&kvmsg); break; // Done } kvmsg_store (&kvmsg, self->kvmap); } zclock_log ("I: received snapshot=%d", (int) self->sequence); zsocket_destroy (self->ctx, snapshot); } // Find and remove update off pending list kvmsg_t *kvmsg = kvmsg_recv (subscriber); if (!kvmsg) return 0; if (strneq (kvmsg_key (kvmsg), "HUGZ")) { if (!s_was_pending (self, kvmsg)) { // If master update came before client update, flip it // around, store master update (with sequence) on pending // list and use to clear client update when it comes later zlist_append (self->pending, kvmsg_dup (kvmsg)); } // If update is more recent than our kvmap, apply it if (kvmsg_sequence (kvmsg) > self->sequence) { self->sequence = kvmsg_sequence (kvmsg); kvmsg_store (&kvmsg, self->kvmap); zclock_log ("I: received update=%d", (int) self->sequence); } else kvmsg_destroy (&kvmsg); } else kvmsg_destroy (&kvmsg); return 0; }
代码不短,不过作者的牢骚更长。(貌似花了一周的时间)
当然作为一个靠谱的模型,总会制定一些规范给某些不太靠谱的人:http://rfc.zeromq.org/spec:12
至此,整个教程算是告一段落了。(之所以这最后一个模型分了三段,着实是代码多了些)
教程结束了,学习才刚开始。至于会不会再有后续,诚如guide结尾:
More coming soon…
结言:
虽然知道翻译技术文章有难度,但着实还是吓着了,在写第一章的时候就打了退堂鼓。终究在自我安慰、勉励下完成了这个系列的笔记(退一步)。好吧,我承认代码、图示占了大比例,不过,好歹算是有始有终的完成了。
原计划一周时间结束的,由于诸多原因(磨蹭,消极,退堂鼓)前后竟然跨了两个多月,总算咬牙坚持了下来,其实不敢说学到了很多,自从中部python的代码不再时,几乎就没有再自己验证代码的可行和逻辑了。写本系列,更多的是自个儿跟自个儿过不去(俺就不信写不完了!)折腾到最后,多少也是有些收获的(谁折腾谁知道~)
回首看看,也就这样了,倒是有些"天凉好个秋"的意味。
也罢,哦了~
评论
8 楼
iyuan
2012-10-10
penelox 写道
由于没有发送状态,所以最后改为boost的asio实现了。谢谢。
还有个问题请教,对于发布订阅模式,当订阅端退出或异常关闭的时候,发布端会不会清掉这个session,如何清掉,不是没有状态回执吗?
还有个问题请教,对于发布订阅模式,当订阅端退出或异常关闭的时候,发布端会不会清掉这个session,如何清掉,不是没有状态回执吗?
不做响应应当的话,可以要求另起一条线路,订阅者定时向发布端发布存活消息,用以刷新session,其实类似心跳,但是不需要那么高频率,而且是另外用一条线路,便不会出现心跳和数据互相影响的麻烦
7 楼
penelox
2012-09-27
由于没有发送状态,所以最后改为boost的asio实现了。谢谢。
还有个问题请教,对于发布订阅模式,当订阅端退出或异常关闭的时候,发布端会不会清掉这个session,如何清掉,不是没有状态回执吗?
还有个问题请教,对于发布订阅模式,当订阅端退出或异常关闭的时候,发布端会不会清掉这个session,如何清掉,不是没有状态回执吗?
6 楼
iyuan
2012-09-21
penelox 写道
你好,前面提到的功能,我基本已经实现。目前还有个问题,就是client端如果崩溃,服务器端如何知道。我想用心跳控制,但是组内讨论觉得心跳耗资源,想从send消息这个动作入手。
所以请问,如何能知道send消息是否被client端收到,还是没有?
我简单查了一下guide,上面说zmq_send只是入发送队列,不为消息是否发送成功负责。请问如何知道发送是否成功被client接收或者未接收,这样就不用维护心跳机制了,
因为我还没来得及详细查询guide,所以才来问你,谢谢~~
所以请问,如何能知道send消息是否被client端收到,还是没有?
我简单查了一下guide,上面说zmq_send只是入发送队列,不为消息是否发送成功负责。请问如何知道发送是否成功被client接收或者未接收,这样就不用维护心跳机制了,
因为我还没来得及详细查询guide,所以才来问你,谢谢~~
原生的是没有这种实现的(第三方实现就不清楚了).zmq的目标是无锁,原子操作,一旦客/服有了回馈机制,理论上来说就完全推翻了zmq的根本,退一步来说,通过中间层来完成这个需求可以却没意义(那还不如直接用rabbitmq之类的自带中间存储/查寻 的队列实现).
总的来说,zmq的应用场景主要是安全性低,速度求快.
对可靠性有要求的话,还是建议换到rabbit之类的中间件
5 楼
penelox
2012-09-21
你好,前面提到的功能,我基本已经实现。目前还有个问题,就是client端如果崩溃,服务器端如何知道。我想用心跳控制,但是组内讨论觉得心跳耗资源,想从send消息这个动作入手。
所以请问,如何能知道send消息是否被client端收到,还是没有?
我简单查了一下guide,上面说zmq_send只是入发送队列,不为消息是否发送成功负责。请问如何知道发送是否成功被client接收或者未接收,这样就不用维护心跳机制了,
因为我还没来得及详细查询guide,所以才来问你,谢谢~~
所以请问,如何能知道send消息是否被client端收到,还是没有?
我简单查了一下guide,上面说zmq_send只是入发送队列,不为消息是否发送成功负责。请问如何知道发送是否成功被client接收或者未接收,这样就不用维护心跳机制了,
因为我还没来得及详细查询guide,所以才来问你,谢谢~~
4 楼
penelox
2012-07-31
哈哈,没办法,我们的项目是分布式的,从后台数据采集、数据库,到服务器和客户端,分别运行在solaris和windows下,
正好赶上windows,改不过来啦 哈哈
正好赶上windows,改不过来啦 哈哈
3 楼
penelox
2012-07-31
谢谢解答
昨天我大体在windows下调试通过了克隆模式的例子了,修改了一些文件,改动不大,c++或c版本的在windows下问题不大了,下一步是还需要弄到c#端,有点头大,或许可以封装成一个dll,给c#调用,呵呵,谢谢啦
昨天我大体在windows下调试通过了克隆模式的例子了,修改了一些文件,改动不大,c++或c版本的在windows下问题不大了,下一步是还需要弄到c#端,有点头大,或许可以封装成一个dll,给c#调用,呵呵,谢谢啦
2 楼
iyuan
2012-07-30
penelox 写道
请教个问题,目前我负责的项目里,需要用到这个发布订阅模式来做通讯机制。
但是问题是我的服务器端是windows C++,客户端是C#,貌似发布订阅模式的克隆模式例子,是用到了C语言的库CZMQ,以及imatix-zguide\examples中的文件,并且只是支持linux环境的。请问如果我想在windows下使用这种模式的上述例子,能实现吗,该如何实现。还有c#客户端那边又该如何编写呢。试着在windows下的vs2010编译,无法通过,请大师帮帮我,呵呵,多谢啦~~~
但是问题是我的服务器端是windows C++,客户端是C#,貌似发布订阅模式的克隆模式例子,是用到了C语言的库CZMQ,以及imatix-zguide\examples中的文件,并且只是支持linux环境的。请问如果我想在windows下使用这种模式的上述例子,能实现吗,该如何实现。还有c#客户端那边又该如何编写呢。试着在windows下的vs2010编译,无法通过,请大师帮帮我,呵呵,多谢啦~~~
这个真没搞过,原作者搞zmq的一大野心便是能被录入到linux核中,windows的真心没有关注过,不过理论上只要符合amqp协议,应该是没有os绑架的。
ps:用c++写zmq,原作者似乎也有吐槽,正在推倒重来(c),具体可以搜索下,还有就是,珍爱生命,远离windows~
1 楼
penelox
2012-07-30
请教个问题,目前我负责的项目里,需要用到这个发布订阅模式来做通讯机制。
但是问题是我的服务器端是windows C++,客户端是C#,貌似发布订阅模式的克隆模式例子,是用到了C语言的库CZMQ,以及imatix-zguide\examples中的文件,并且只是支持linux环境的。请问如果我想在windows下使用这种模式的上述例子,能实现吗,该如何实现。还有c#客户端那边又该如何编写呢。试着在windows下的vs2010编译,无法通过,请大师帮帮我,呵呵,多谢啦~~~
但是问题是我的服务器端是windows C++,客户端是C#,貌似发布订阅模式的克隆模式例子,是用到了C语言的库CZMQ,以及imatix-zguide\examples中的文件,并且只是支持linux环境的。请问如果我想在windows下使用这种模式的上述例子,能实现吗,该如何实现。还有c#客户端那边又该如何编写呢。试着在windows下的vs2010编译,无法通过,请大师帮帮我,呵呵,多谢啦~~~
发表评论
-
IM选型(初)
2016-08-23 19:12 1635主要参考文章: https://r ... -
关于python和rabbitmq的那点事儿
2011-10-19 14:15 7956rabbitmq是一个消息中间件,在之前的zmq介绍中有略带提 ... -
zeroMQ初体验-33.发布/订阅模式进阶-克隆模式-中
2011-05-26 15:37 2905临时缓存 现实中,比如 ... -
zeroMQ初体验-32.发布/订阅模式进阶-克隆模式-上
2011-05-26 15:04 3648在发布/订阅模式中,特别是现实应用中,总会因为这样那样的问题导 ... -
zeroMQ初体验-31.发布/订阅模式进阶-黑盒的高速订阅者
2011-05-25 16:55 2751作为发布/订阅模式的一个常用场景,大数据量的组播是有必要的。虽 ... -
zeroMQ初体验-30.发布/订阅模式进阶-自裁的蜗牛订阅者
2011-05-25 16:24 4537在初次介绍发布/订阅模式的时候,就已经抖出了这个包袱:如果订阅 ... -
zeroMQ初体验-29.可靠性-自由模式
2011-05-24 17:02 5398好吧,本以为这可能是一个更靠谱的模式,谁知(其实是我一厢情愿了 ... -
zeroMQ初体验-28.可靠性-主从模式
2011-05-23 14:47 5512虽然"硬盘模式" ... -
zeroMQ初体验-27.可靠性-硬盘模式
2011-05-23 13:44 3791在之前的种种模式中, ... -
zeroMQ初体验-26.可靠性-管家模式
2011-05-12 19:05 5648上一节末尾有说到协议,zeromq自然做了充沛的封装,&quo ... -
zeroMQ初体验-26.可靠性-管家模式
2011-05-12 19:03 1上一节末尾有说到协议,zeromq自然做了充沛的封装,&quo ... -
zeroMQ初体验-25.可靠性-偏执的海盗模式
2011-05-05 19:05 3563虽然说“简单的海盗模 ... -
zeroMQ初体验-24.可靠性-简单的海盗模式
2011-05-05 16:41 3208相较于“懒惰的”做了 ... -
zeroMQ初体验-23.可靠性-懒惰的海盗模式
2011-05-05 16:15 5059相较于通常的阻塞模式,这里只是做了一点简单的动作来加强系统的可 ... -
zeroMQ初体验-22.可靠性-总览
2011-04-26 19:25 5929在开篇就从曾对zeromq的可靠性做过质疑,不过,作为一个雄心 ... -
rabbitmq 队列长度预设的曲线方案
2011-04-21 14:36 3376zeromq中倒是直接支持这个功能的。 类似于设定队列长度或 ... -
zeroMQ初体验-21.应答模式进阶(七)-云计算
2011-04-18 19:14 3529这里给出了一个最近很火的"云计算"案例。 ... -
zeroMQ初体验-20.应答模式进阶(六)-多对多路由模式
2011-04-18 17:22 3868某些时候,为了冗余的需要,可能会有这样的需求: impo ... -
zeroMQ初体验-19.应答模式进阶(五)-异步式应答
2011-04-15 15:23 4832恩,这应该算是比较实 ... -
zeroMQ初体验-18.应答模式进阶(四)-定制路由3
2011-04-02 15:39 5175从经典到超越经典。 首 ...
相关推荐
ZeroMQ支持多种协议,如PUB/SUB(发布/订阅)、REQ/REP(请求/响应)和PUSH/PULL(推送/拉取),这些模式提供了灵活的消息传递模型。此外,它还提供了一些高级特性,比如负载均衡、故障恢复和多路复用。 在实际使用...
6. **分布式**:ZeroMQ 支持多对多的发布/订阅模式,使得构建分布式系统更加容易。 zeromq-4.0.3.tar.gz 文件本身是一个 tar 归档,通常用于在 Unix-like 系统上打包和存储文件。归档后,文件被压缩为 .gz 格式,这...
这些套接字支持多种消息模式,包括请求/响应、发布/订阅、推送/拉取以及对等模式,使得开发者可以轻松地处理点对点、一对多和多对多的通信场景。 zeromq的安装过程一般包括解压、配置、编译和安装四个步骤: 1. **...
这个“zeromq-4.3.4.tar.gz”文件是0MQ库的4.3.4稳定版本,发布于2021年1月17日。下面我们将深入探讨0MQ的核心特性、主要功能以及如何使用这一版本。 1. **0MQ简介** - 0MQ不是一个传统的消息队列系统,而是一种在...
zeromq的核心特性包括点对点连接、发布/订阅模式、请求/响应模式以及推拉模式,这些模式为各种通信场景提供了基础。4.1.8版本可能包含了一些错误修复、性能提升或者新功能的添加,具体更新内容可以在其官方 change...
这里提供的四个压缩包文件,Python-2.6.6.tar.bz2、zeromq-3.2.5.tar.gz、jzmq.tar.gz以及storm-0.8.0.zip,都是与Storm搭建和运行相关的资源。 首先,我们来详细了解一下每个文件的作用: 1. **Python-2.6.6.tar....
1. **套接字(Sockets)**:在ZeroMQ中,套接字不仅仅是传统网络编程中的概念,它们提供了多种模式,如PUB(发布者)、SUB(订阅者)、REQ(请求者)、REP(响应者)、DEALER(经销商)和ROUTER(路由器),这些模式...
1. **消息队列模型**:ZeroMQ 提供了多种消息模式,如 Pub/Sub(发布/订阅)、Req/Rep(请求/响应)、PUSH/PULL(推/拉)和 XPUB/XSUB(扩展发布/订阅)。这些模式覆盖了各种通信场景,让开发者能够灵活选择最适合其...
3. **模式丰富**:支持多种消息模式,如发布/订阅、请求/应答、推送/拉取和一对多等,这些模式可以灵活地组合以适应不同的应用场景。 4. **高可用性**:具有消息持久化和负载均衡功能,确保在故障情况下仍能保持...
官方离线安装包,测试可用。使用rpm -ivh [rpm完整包名] 进行安装
zeromq的设计基于发布/订阅(Pub/Sub)、请求/应答(Req/Rep)和推送/拉取(Push/Pull)等经典的消息模式。这些模式覆盖了各种常见的分布式系统通信场景,如服务间调用、事件驱动架构、工作队列等。通过这些模式,...
ZeroMQ的核心概念是Socket(套接字),它提供了类似于网络编程中的套接字接口,但增加了许多高级功能,比如消息队列、负载均衡、高可用性和订阅/发布模式等。这些特性使得ZeroMQ成为构建分布式系统、微服务架构和...
- 负载均衡:发布/订阅模式下,消息可以广播给所有订阅者,而推送/拉取模式则可以实现负载均衡。 总的来说,zeromq是一个功能强大、性能优异的开源消息中间件,对于需要高效、可靠通信的分布式系统,如storm这样的...
这个“zeromq-4.1.0-rc1.zip”压缩包包含了ZeroMQ 4.1.0版本的源代码,这是一个预发布版本(Release Candidate),意味着它是正式版发布前的最后一个测试版本。 ZeroMQ的核心概念是提供一种抽象的网络通信层,允许...
首先,zeromq支持多种协议,包括TCP、IPC(进程间通信)、PUB/SUB(发布/订阅)、REQ/REP(请求/响应)、PAIR(对等)和DEALER/ROUTER(经销商/路由器)模式。这些模式为不同场景提供了灵活的选择,比如PUB/SUB模式...
ZeroMQ是一个网络通讯库,其主要用来为分布式应用程序开发提供进程间通信(此处的进程既可以是同一台机器上的两个进程也可以是不同机器上的两个进程)。ZeroMQ的特点在于灵活的通信手段和丰富的连接模型,并且它可以...
ZeroMQ是一个网络通讯库,其主要用来为分布式应用程序开发提供进程间通信(此处的进程既可以是同一台机器上的两个进程也可以是不同机器上的两个进程)。ZeroMQ的特点在于灵活的通信手段和丰富的连接模型,并且它可以...
ZMQ(以下ZeroMQ简称ZMQ)是一个简单好用的传输层,像框架一样的一个socket library,他使得Socket编程更加简单、简洁和性能更高。是一个消息处理队列库,可在多个线程、内核和主机盒之间弹性伸缩。
在Storm中,零MQ作为数据传输的基础,它支持发布/订阅、请求/响应以及推拉等多种消息模式,使得Storm能够有效地处理实时数据流并确保数据的可靠传输。版本3.12.5是该库的一个稳定版本,可能包含了一些性能优化和bug...
2. **模式丰富**:支持多种消息模式,如发布/订阅(Publish/Subscribe)、请求/响应(Request/Reply)、推拉(Push/Pull)以及管道对(Pair)。这些模式可以灵活地适应不同的应用场景。 3. **高并发**:ZeroMQ利用I...