【ZeroMQ】ZeroMQ入门

已于 2024-06-28 12:22:45 修改
阅读量2.2k 收藏 7
点赞数
分类专栏： C++后端 文章标签： 网络
于 2022-03-20 16:45:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37717687/article/details/123435395
版权

ZeroMQ入门

ZeroMQ入门和进阶

ZeroMQ下载编译

源码下载地址：http://download.zeromq.org/

ubuntu安装必须的库

sudo apt-get install libtool 
sudo apt-get install pkg-config 
sudo apt-get install build-essential 
sudo apt-get install autoconf 
sudo apt-get install automake

安装加密库

Sodium⼀个易于使用的可为我们提供加密、解密、签名，密码哈希等功能的软件库。除了自身强⼤的功能外，它还为我们提供了⼀个兼容API和⼀个外部API，以进⼀步的帮助我们提高其可用性。Sodium的目标是提供构建更高级别加密工具所需的所有核心操作。

若命令行不能安装，则去这个github网址手动下载并解压

git clone git://github.com/jedisct1/libsodium.git 
cd libsodium 
./autogen.sh -s 
./configure && make check 
sudo make install 
sudo ldconfig 
cd ..

下载、编译、安装libzmq

# 下载 
git clone https://github.com/zeromq/libzmq.git 
cd libzmq 
# 查看tag 
git tag 
# 版本 获取指定的版本，不要⽤主分⽀，可能有bug 
git checkout v4.3.4 
./autogen.sh 
./configure && make check 
sudo make install 
sudo ldconfig 
cd ..

编译debug版本时使用 ./configure --enable-debug

sudo make install的是时候可以看到具体的.so和.a
libtool: install: /usr/bin/install -c src/.libs/libzmq.lai /usr/local/lib/libzmq.la
libtool: install: /usr/bin/install -c src/.libs/libzmq.a /usr/local/lib/libzmq.a
libtool: install: chmod 644 /usr/local/lib/libzmq.a
libtool: install: ranlib /usr/local/lib/libzmq.a
libtool: finish: PATH=“/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/snap/bin:/sbin” ldconfig - n /usr/local/lib
我们在编译的时候需要加上libzmq库，⽐如gcc -o bin file.c -lzmq

ZeroMQ文档

官方API: http://api.zeromq.org/

英文指南：http://zguide.zeromq.org/page:all

中文指南：https://github.com/anjuke/zguide-cn，文档里面的代码有些是过时的，需要参考提供的github链接的代码

性能测试：http://wiki.zeromq.org/results:perf-howto

ZeroMQ 解决传统网络编程的问题

◼ 调用的socket接口较多；
◼ TCP是一对一的连接；- 一对多 ， reactor模式
◼ 编程需要关注很多socket细节问题；
◼ 不支持跨平台编程；
◼ 需要自行处理分包、组包问题；
◼ 流式传输时需处理粘包、半包问题；
◼ 需自行处理网络异常，比如连接异常中断、重连等；
◼ 服务端和客户端启动有先后；
◼ 自行处理IO模型；
◼ 自行实现消息的缓存 （消息水位）；
◼ 自行实现对消息的加密

ZeroMQ模型介绍

【1】REQ/REP 请求响应模型

在这里插入图片描述

【2】PUB/SUB 发布订阅模型

在这里插入图片描述

【3】PUSH/PULL 推拉模型

请添加图片描述
如上图所示，push/pull既可以做客户端，也可以做服务端。

  • Ventllator push推送信息
  • 多个Worker pull拉取信息消费，然后把结果push给Sink
  • Sink pull拉取结果消费。

这个模式有点像多线程竞争从全局队列获取消息进行消费。

【4】ROUTER/DEALER 模型

在这里插入图片描述

PUB/SUB模型与PUSH/PULL模型的区别

在这里插入图片描述

  • PUB/SUB模型中，client发的消息，不同的server可接收所有的msg进行消费（同topic）。
  • PUSH/PULL模型中，client发的消息，不同server接收指定的msg进行消费。类似于多线程从全局队列取消息模型。

ZeroMQ应用范例

【1】REQ/REP 请求响应模型

hwclient.c

#include <zmq.h>
#include <string.h>
#include <stdio.h>
#include <unistd.h>
//编译：gcc -o hwclient hwclient.c -lzmq
int main (void)
{
    printf ("Connecting to hello world server...\n");
    void *context = zmq_ctx_new ();
    //  连接至服务端的套接字
    void *requester = zmq_socket (context, ZMQ_REQ);
    zmq_connect (requester, "tcp://localhost:5555");

    int request_nbr;
    int ret = 0;
    for (request_nbr = 0; request_nbr != 10; request_nbr++) {
        char buffer [10];
        printf ("正在发送1 Hello %d...\n", request_nbr);
        ret = zmq_send (requester, "Hello", 5, 0);
         printf ("zmq_send1 ret:%d\n", ret);
        printf ("正在发送2 Hello %d...\n", request_nbr);
        ret = zmq_send (requester, "Hello", 5, 0);
        printf ("zmq_send2 ret:%d\n", ret);
        zmq_recv (requester, buffer, 6, 0);        // 收到响应才能再发
        zmq_recv (requester, buffer, 6, 0); 
        printf ("接收到 World %d\n", request_nbr);
    }
    zmq_close (requester);
    zmq_ctx_destroy (context);
    return 0;
}

hwserver.c

#include <zmq.h>
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <assert.h>
//gcc -o hwserver hwserver.c -lzmq
int main (void)
{
    //  Socket to talk to clients
    void *context = zmq_ctx_new ();
    //  与客户端通信的套接字
    void *responder = zmq_socket (context, ZMQ_REP);
    int rc = zmq_bind (responder, "tcp://*:5555");  // 服务器要做绑定
    assert (rc == 0);

    while (1) {
        //  等待客户端请求
        char buffer [10];
        int size = zmq_recv (responder, buffer, 10, 0);
        buffer[size] = '\0';
        printf ("收到 %s\n", buffer);
        sleep (1);          //  Do some 'work'
        //  返回应答
        zmq_send (responder, "World", 5, 0);
    }
    return 0;
}

开启hwserver

# ./hwserver

调试hwclient

# gdb hwclient	//开始gdb调试

(gdb) b main	//打断点到main函数

(gdb) r	//重新开始运行文件（run-text：加载文本文件，run-bin：加载二进制文件）

(gdb) c	//继续运行

# ctrl+c //终止/中断运行

(gdb) info threads	//查看hwclient进程有多少个线程，如下可见开了3个线程
  Id   Target Id         Frame 
  3    Thread 0x7ffff65c7700 (LWP 29297) "ZMQbg/IO/0" 0x00007ffff7b0c0e3 in epoll_wait ()
   from /lib64/libc.so.6
  2    Thread 0x7ffff6dc8700 (LWP 29296) "ZMQbg/Reaper" 0x00007ffff7b0c0e3 in epoll_wait ()
   from /lib64/libc.so.6
* 1    Thread 0x7ffff7ef0740 (LWP 29292) "hwclient" 0x00007ffff7b00ddd in poll () from /lib64/libc.so.6

(gdb) thread 3	//切换到线程3
[Switching to thread 3 (Thread 0x7ffff65c7700 (LWP 29297))]
#0  0x00007ffff7b0c0e3 in epoll_wait () from /lib64/libc.so.6

(gdb) bt	//查看堆栈信息，可见线程3用到了epoll
#0  0x00007ffff7b0c0e3 in epoll_wait () from /lib64/libc.so.6
#1  0x00007ffff7f2e22b in zmq::epoll_t::loop (this=0x4095b0) at src/epoll.cpp:184
#2  0x00007ffff7f4f2d9 in zmq::worker_poller_base_t::worker_routine (arg_=0x4095b0)
    at src/poller_base.cpp:146
#3  0x00007ffff7f7a060 in thread_routine (arg_=0x409608) at src/thread.cpp:257
#4  0x00007ffff75f0ea5 in start_thread () from /lib64/libpthread.so.0
#5  0x00007ffff7b0bb0d in clone () from /lib64/libc.so.6

(gdb) q	//退出gdb
【2】PUB/SUB 发布订阅模型

wuclient.c

#include "zhelpers.h"
//编译：gcc -o wuclient wuclient.c -lzmq
int main (int argc, char *argv [])
{
    //  Socket to talk to server
    printf ("Collecting updates from weather server...\n");
    void *context = zmq_ctx_new ();
    void *subscriber = zmq_socket (context, ZMQ_SUB);
    printf("zmq_connect\n");
    int rc = zmq_connect (subscriber, "tcp://localhost:5556");
    assert (rc == 0);

    //  Subscribe to zipcode, default is NYC, 10001
    const char *filter = (argc > 1)? argv [1]: "10001 ";
    printf("ZMQ_SUBSCRIBE\n");
    rc = zmq_setsockopt (subscriber, ZMQ_SUBSCRIBE,
                         filter, strlen (filter));  // 字符匹配的方式
    assert (rc == 0);

    //  Process 100 updates
    int update_nbr;
    long total_temp = 0;
    printf("into for\n");
    for (update_nbr = 0; update_nbr < 100; update_nbr++) {
        char *string = s_recv (subscriber);

        int zipcode, temperature, relhumidity;
        sscanf (string, "%d %d %d",
            &zipcode, &temperature, &relhumidity);
        total_temp += temperature;
        printf("zipcode = %d, temperature:%d\n", zipcode, temperature);
        free (string);
    }
    printf ("Average temperature for zipcode '%s' was %dF\n",
        filter, (int) (total_temp / update_nbr));

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

wuserver.c

#include "zhelpers.h"
int main (void)
{
    //  Prepare our context and publisher
    void *context = zmq_ctx_new ();
    void *publisher = zmq_socket (context, ZMQ_PUB);
    int rc = zmq_bind (publisher, "tcp://*:5556");
    assert (rc == 0);

    //  Initialize random number generator
    srandom ((unsigned) time (NULL));
    int zipcode, temperature, relhumidity;
    temperature = 0;
    while (1) {
        //  Get values that will fool the boss
        int zipcode, temperature, relhumidity;
        zipcode     = randof (100000);
        // zipcode = 10001;
        if(++temperature < 0)
            temperature = 0;

        relhumidity = randof (50) + 10;

        //  Send message to all subscribers
        char update [20];
        sprintf (update, "%05d %d %d", zipcode, temperature, relhumidity);
        printf ("pub %05d %d %d\n", zipcode, temperature, relhumidity);
        s_send (publisher, update);     // 发布是不管有没有人订阅
        // sleep(1);
    }
    zmq_close (publisher);
    zmq_ctx_destroy (context);
    return 0;
}

启动服务器

# ./wuserver

客户端1订阅10001频道

# ./wuclient 10001
zmq_connect
ZMQ_SUBSCRIBE
into for
zipcode = 10001, temperature:155055
zipcode = 10001, temperature:291385
zipcode = 10001, temperature:343617
zipcode = 10001, temperature:486772
zipcode = 10001, temperature:554440
zipcode = 10001, temperature:668110
...

客户端2订阅10002频道

# ./wuclient 10002
zmq_connect
ZMQ_SUBSCRIBE
into for
zipcode = 10002, temperature:38414
zipcode = 10002, temperature:100755
zipcode = 10002, temperature:125598
zipcode = 10002, temperature:196114
...
【3】PUSH/PULL 推拉模型

taskvent.c

#include "zhelpers.h"
int main (void) 
{
    void *context = zmq_ctx_new ();

    //  Socket to send messages on
    void *sender = zmq_socket (context, ZMQ_PUSH);
    zmq_bind (sender, "tcp://*:5557");

    //  Socket to send start of batch message on
    void *sink = zmq_socket (context, ZMQ_PUSH);
    zmq_connect (sink, "tcp://localhost:5558");

    printf ("Press Enter when the workers are ready: ");
    getchar ();
    printf ("Sending tasks to workers...\n");

    //  The first message is "0" and signals start of batch
    s_send (sink, "0");

    //  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 = randof (100) + 1;
        total_msec += workload;
        char string [10];
        sprintf (string, "%d", workload);
        s_send (sender, string);    // 用户层没有关注pull
    }
    printf ("Total expected cost: %d msec\n", total_msec);

    zmq_close (sink);
    zmq_close (sender);
    zmq_ctx_destroy (context);
    return 0;
}

taskwork.c

#include "zhelpers.h"
int main (void) 
{
    //  Socket to receive messages on
    void *context = zmq_ctx_new ();
    void *receiver = zmq_socket (context, ZMQ_PULL);
    zmq_connect (receiver, "tcp://localhost:5557");

    //  Socket to send messages to
    void *sender = zmq_socket (context, ZMQ_PUSH);
    zmq_connect (sender, "tcp://localhost:5558");

    //  Process tasks forever
    while (1) {
        char *string = s_recv (receiver);
        printf ("%s.", string);     //  Show progress
        fflush (stdout);
        s_sleep (atoi (string));    //  Do the work
        free (string);
        s_send (sender, "");        //  Send results to sink 把结果发送给sink
    }
    zmq_close (receiver);
    zmq_close (sender);
    zmq_ctx_destroy (context);
    return 0;
}

tasksink.c

#include "zhelpers.h"
int main (void) 
{
    //  Prepare our context and socket
    void *context = zmq_ctx_new ();
    void *receiver = zmq_socket (context, ZMQ_PULL);
    zmq_bind (receiver, "tcp://*:5558");

    //  Wait for start of batch
    char *string = s_recv (receiver);
    free (string);

    //  Start our clock now
    int64_t start_time = s_clock ();

    //  Process 100 confirmations
    int task_nbr;
    for (task_nbr = 0; task_nbr < 100; task_nbr++) {
        char *string = s_recv (receiver);
        free (string);
        if (task_nbr % 10 == 0)
            printf (":");
        else
            printf (".");
        fflush (stdout);
    }
    //  Calculate and report duration of batch
    printf ("Total elapsed time: %d msec\n", 
        (int) (s_clock () - start_time));

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

开启taskvent

# ./taskvent 
Press Enter when the workers are ready: 
Sending tasks to workers...
Total expected cost: 4830 msec

开启tasksink

# ./tasksink 
:.........:.........:.........:.........:.........:.........:.........:.........:.........:.........Total elapsed time: 2640 msec

开启taskwork1

# ./taskwork 
69.72.7.85.100.89.19.16.75.52.20.97.78.32.57.74.55.77.83.3.95.37.2.67.83.33.19.6.8.97.6.90.15.22.28.79.14.36.69.91.20.54.53.34.97.25.100.62.80.11.

开启taskwork2

# ./taskwork 
87.52.38.41.34.55.11.54.31.58.100.4.79.2.69.26.45.62.62.82.91.13.53.76.19.3.30.96.38.65.70.60.67.97.24.23.16.16.2.51.24.38.60.61.30.2.14.15.83.8.
【4】ROUTER/DEALER 模型

rrworker.c

#include "zhelpers.h"
#include <unistd.h>
int main (void) 
{
    void *context = zmq_ctx_new ();

    //  Socket to talk to clients
    void *responder = zmq_socket (context, ZMQ_REP);
    zmq_connect (responder, "tcp://localhost:5560");

    while (1) {
        //  Wait for next request from client
        char *string = s_recv (responder);
        printf ("Received request: [%s]\n", string);
        free (string);

        //  Do some 'work'
        sleep (1);

        //  Send reply back to client
        s_send (responder, "World");
    }
    //  We never get here, but clean up anyhow
    zmq_close (responder);
    zmq_ctx_destroy (context);
    return 0;
}

rrworker2.c

#include "zhelpers.h"
#include <unistd.h>
int main (void) 
{
    void *context = zmq_ctx_new ();

    //  Socket to talk to clients
    void *responder = zmq_socket (context, ZMQ_REP);
    zmq_connect (responder, "tcp://localhost:5560");

    while (1) {
        //  Wait for next request from client
        char *string = s_recv (responder);
        printf ("Received request: [%s]\n", string);
        free (string);

        //  Do some 'work'
        sleep (1);

        //  Send reply back to client
        s_send (responder, "World2");
    }
    //  We never get here, but clean up anyhow
    zmq_close (responder);
    zmq_ctx_destroy (context);
    return 0;
}

rrbroker.c

//  Simple request-reply broker
#include "zhelpers.h"

int main (void) 
{
    //  Prepare our context and sockets
    void *context = zmq_ctx_new ();
    void *frontend = zmq_socket (context, ZMQ_ROUTER);
    void *backend  = zmq_socket (context, ZMQ_DEALER);
    zmq_bind (frontend, "tcp://*:5559");
    zmq_bind (backend,  "tcp://*:5560");

    //  Initialize poll set
    zmq_pollitem_t items [] = {
        { frontend, 0, ZMQ_POLLIN, 0 },
        { backend,  0, ZMQ_POLLIN, 0 }
    };
    //  Switch messages between sockets
    while (1) {
        zmq_msg_t message;
        zmq_poll (items, 2, -1);
        if (items [0].revents & ZMQ_POLLIN) {
            while (1) {
                //  Process all parts of the message
                zmq_msg_init (&message);
                zmq_msg_recv (&message, frontend, 0);
                int more = zmq_msg_more (&message);
                zmq_msg_send (&message, backend, more? ZMQ_SNDMORE: 0);
                zmq_msg_close (&message);
                if (!more)
                    break;      //  Last message part
            }
        }
        if (items [1].revents & ZMQ_POLLIN) {
            while (1) {
                //  Process all parts of the message
                zmq_msg_init (&message);
                zmq_msg_recv (&message, backend, 0);
                int more = zmq_msg_more (&message);
                zmq_msg_send (&message, frontend, more? ZMQ_SNDMORE: 0);
                zmq_msg_close (&message);
                if (!more)
                    break;      //  Last message part
            }
        }
    }
    //  We never get here, but clean up anyhow
    zmq_close (frontend);
    zmq_close (backend);
    zmq_ctx_destroy (context);
    return 0;
}

rrclient.c

#include "zhelpers.h"
int main (void) 
{
    void *context = zmq_ctx_new ();

    //  Socket to talk to server
    void *requester = zmq_socket (context, ZMQ_REQ);
    zmq_connect (requester, "tcp://localhost:5559");

    int request_nbr;
    for (request_nbr = 0; request_nbr != 10; request_nbr++) {
        s_send (requester, "Hello");
        char *string = s_recv (requester);
        printf ("Received reply %d [%s]\n", request_nbr, string);
        free (string);
    }
    zmq_close (requester);
    zmq_ctx_destroy (context);
    return 0;
}

开启rrworker

# ./rrworker
Received request: [Hello]
Received request: [Hello]
Received request: [Hello]
Received request: [Hello]
Received request: [Hello]
Received request: [Hello]
Received request: [Hello]
Received request: [Hello]
Received request: [Hello]
Received request: [Hello]
Received request: [Hello]
Received request: [Hello]
Received request: [Hello]
Received request: [Hello]
Received request: [Hello]

开启rrworker2

# ./rrworker2
Received request: [Hello]
Received request: [Hello]
Received request: [Hello]
Received request: [Hello]
Received request: [Hello]
Received request: [Hello]
Received request: [Hello]
Received request: [Hello]
Received request: [Hello]
Received request: [Hello]

开启rrbroker

# ./rrbroker

开启rrclient1

# ./rrclient 
Received reply 0 [World2]
Received reply 1 [World2]
Received reply 2 [World2]
Received reply 3 [World2]
Received reply 4 [World2]
Received reply 5 [World2]
Received reply 6 [World2]
Received reply 7 [World2]
Received reply 8 [World]
Received reply 9 [World2]

开启rrclient2

# ./rrclient 
Received reply 0 [World]
Received reply 1 [World2]
Received reply 2 [World]
Received reply 3 [World]
Received reply 4 [World]
Received reply 5 [World]
Received reply 6 [World]
Received reply 7 [World]
Received reply 8 [World]
Received reply 9 [World]

ZeroMQ存在的问题

ZeroMQ使用的不如Kafka、RocketMQ广泛的主要原因：

  1. 耦合的问题。程序要继承ZeroMQ本身
  2. 无法集群
  3. 无副本模式
  4. 无法持久化
Leoh_LL
关注
专栏目录
ZeroMQ初体验.rar_ZeroMQ初体验_zeromq
09-25
希望对ZeroMQ小白学习有点帮助，都是很基础的东西
zeromq安装包
01-10
“ZMQ(以下ZeroMQ简称ZMQ)是一个简单好用的传输层，像框架一样的一个socket library，他使得Socket编程更加简单、简洁和性能更高。是一个消息处理队列库，可在多个线程、内核和主机盒之间弹性伸缩。ZMQ的明确目标是“成为标准网络协议栈的一部分，之后进入Linux内核”。现在还未看到它们的成功。但是，它无疑是极具前景的、并且是人们更加需要的“传统”BSD套接字之上的一 层封装。ZMQ让编写高性能网络应用程序极为简单和有趣。”
ZeroMQ【01】安装
最新发布
aaronman90的专栏
08-28 33
想用arm-linux-gcc版本的，那么就的添加–host参数，以下其他操作都是相同，但是最后一步，需要将编译成功的lib下的库文件libzmq.so.5复制到ARM开发板的lib库文件夹当中。安装完成之后动态库文件默认在/usr/local/lib/目录下，头文件默认在/usr/local/include/目录下。3.配置（不安装sodium加密库）执行下面的命令重新加载动态库。2.下载zeromq。
[zz]zeroMQ安装
weixin_33858485的博客
03-28 114
边安装边写 1.下载 posix版:http://download.zeromq.org/zeromq-2.1.7.tar.gz win版：http://download.zeromq.org/zeromq-2.1.7.zip 2.安装 tar -zxvf zeromq-2.1.7.tar.gz cd zeromq-2.1.7 ls ./configure --...
非root帐号安装zeromq和jzmq
blue_jjw的专栏
07-12 2682
安装storm需要首先安装zeromq和jzmq，root帐号安装见twitter storm安装和storm-start的本地运行 如果不是root帐号，那么是无法把库装到默认的/usr/local/lib中，下面是非root帐号的安装办法 例如以guest帐号登陆 1.安装zeromq wget http://download.zeromq.org/zeromq-2.1.7.t
ZeroMQ(java)之push/pull模式
fjs的专栏
11-21 1万+
ZeroMQ(java)之push/pull模式 可以用于非常方便的实现任务分发，分布式数据统计等
zeromq linux安装包下载
05-13
linux centos zmq tar.gz
ZeroMQ研究与应用分析
kobejayandy的专栏
09-15 3268
1  ZeroMQ概述 ZeroMQ是一种基于消息队列的多线程网络库，其对套接字类型、连接处理、帧、甚至路由的底层细节进行抽象，提供跨越多种传输协议的套接字。ZeroMQ是网络通信中新的一层，介于应用层和传输层之间（按照TCP/IP划分），其是一个可伸缩层，可并行运行，分散在分布式系统间。 2  系统架构 2.1 总体架构 ZeroMQ几乎所有的I/O操作都是异
ZeroMQ基础入门
顺其自然~专栏
08-13 5407
mq是消息队列（message queue）的简称，目前有多种消息队列可用，包括RabbitMQ、Kafka等，它们各有特色，可以结合具体的项目需求使用。 ZeroMQ简称Zmq，或者0mq，核心引擎由c++编写，是轻量级消息通信库，在对传统的标准socket接口扩展的基础上形成的特色消息通信中间件。 Zmq提供了异步消息队列的抽象，具有多种消息通信模式，能够实现消息过滤，能够无缝对接多种传输协议。 简言之，使用socket时，需要显式地建立连接、销毁连接、选择协议（TCP/UDP）和处理错误等，而Z
一文带你入门了解“零之禅“消息队列ZeroMQ
热门推荐
董哥的黑板报
05-08 2万+
一、ZeroMQ概述 ZeroMQ（又名ØMQ，MQ，或zmq）看起来像一个可嵌入的网络库，但其作用就像一个并发框架 ZeroMQ类似于标准Berkeley套接字，其提供了各种传输工具，如进程内、进程间、TCP和组播中进行原子消息传送的套接字 你可以使用各种模式实现N对N的套接字连接，这些模式包括：扇出、发布-订阅、任务分配、请求-应答 ZeroMQ的速度足够快，因此可充当集群产品的结构 ...
ZMQ/ZeroMQ使用手册
07-06
手册内包含了ZeroMQ的基础入门知识，适合新手学习；介绍了ZeroMQ的集中模式包括高级请求-应答模式； 手册目录：ZeroMQ基础、ZeroMQ进阶、高级请求-应答模式、可靠的请求-应答模式、高级发布-订阅模式。 ZMQ（ØMQ、...
ZeroMQ.rar
05-09
**入门案例** 使用ZeroMQ，首先需要安装对应的库文件，然后根据编程语言的API来创建上下文、套接字和绑定或连接端点。例如，在Java中，创建一个简单的发布-订阅模式： ```java import org.zeromq.ZMQ; public ...
消息队列zeromq4.1.8版本安装包
03-28
总的来说，zeromq4.1.8版本安装包提供了一个可靠的方式来获取和学习zeromq，无论你是初学者还是有经验的开发者，都可以通过这个包快速入门并利用zeromq的强大功能来构建高效的分布式系统。在使用过程中，务必注意...
The ZeroMQ Guide - for C Developers
03-11
零基础入门 书中的“基础知识”章节是学习ZeroMQ的起点。首先，作者提出修复世界的问题，暗示ZeroMQ的设计目标是解决传统通信模型的痛点，如网络延迟、并发处理以及复杂的连接管理。作者强调，ZeroMQ的核心假设是...
一些zeromq的pdf集合
10-11
1. **zeroMq.pdf**：这可能是ZeroMQ的官方文档或者介绍，会涵盖ZeroMQ的基本概念、API使用、工作模式等内容，是初学者入门的好资料。 2. **ZMQ指南.pdf**：这份指南可能详细介绍了ZeroMQ的各种特性和最佳实践，可能...
消息库-ZeroMQ介绍
希望能帮助大家，希望大家多多支持，你们的支持是我前进的动力。
05-20 1749
ZeroMQ (也称为 ØMQ, zmq 或 libzmq) 是一个高性能的异步消息传递库，用于构建分布式或并发应用程序。它提供了一个消息队列的抽象，允许不同的计算机和进程之间进行消息传递，而无需关心底层网络细节。ZeroMQ 不是一个传统意义上的消息队列服务器，而是一个嵌入到应用程序中的库，它提供了多种消息传递模式，如请求-应答、发布-订阅、推-拉等。
ZeroMQ简介(有例子)
周遭.
09-27 3795
ZeroMQZeroMQ是一个库，不是消息队列也不是消息中间件，介于应用层和传输层之间（按照TCP/IP划分），它既不是TCP也不是Socket，而是在Socket封装一层的并行开发框架，它提供线程间、进程间以及网络间的消息信道。传统的Socket通信模式需要创建连接，销毁连接，选择协议等一些列操作，而使用ZeroMQ恰恰避开了这些逻辑上的繁琐，从而使得其应用广泛。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值