ZeroMQ的使用

最新推荐文章于 2025-06-22 14:09:54 发布
转载 最新推荐文章于 2025-06-22 14:09:54 发布 · 1.1k 阅读 · 5

1. 下载zeromq

 C: git clone http://github.com/zeromq/libzmq；

2. 编译

编译zmqlib：启动开始菜单 vs2017下的x64 Native Tools Command Prompt for VS 2017。

mkdir -p src\libzmq\build;

cd src\libzmq\build;

cmake ..

vs2017打开ZeroMQ.sln。编译。

3.使用：

A.publisher-subscriber模式

server:

  1. #include <zmq.h>
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <string.h>
  5. #include <assert.h>
  6. #include <time.h>
  7. #if (!defined (WIN32))
  8. # include <sys/time.h>
  9. #endif
  10. #if (defined (WIN32))
  11. # include <windows.h>
  12. #endif
  13. int main (void)
  14. {
  15. // Prepare our context and publisher
  16. void *context = zmq_ctx_new ();
  17. void *publisher = zmq_socket (context, ZMQ_PUB);
  18. int rc = zmq_bind (publisher, "tcp://*:5556");
  19. assert (rc == 0);
  20. // Initialize random number generator
  21. srand((unsigned) time (NULL));
  22. while (1) {
  23. // Get values that will fool the boss
  24. int zipcode, temperature, relhumidity;
  25. zipcode = rand()%(100000);
  26. temperature = rand()%(215) - 80;
  27. relhumidity = rand()%(50) + 10;
  28. // Send message to all subscribers
  29. char update [20];
  30. sprintf (update, "%05d %d %d", zipcode, temperature, relhumidity);
  31. zmq_send (publisher, update, strlen (update), 0);
  32. }
  33. zmq_close (publisher);
  34. zmq_ctx_destroy (context);
  35. return 0;
  36. }



client:

  1. #include <zmq.h>
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <string.h>
  5. #include <assert.h>
  6. #include <time.h>
  7. #if (!defined (WIN32))
  8. # include <sys/time.h>
  9. #endif
  10. #if (defined (WIN32))
  11. # include <windows.h>
  12. #endif
  13. int main (int argc, char *argv [])
  14. {
  15. // Socket to talk to server
  16. printf ("Collecting updates from weather server...\n");
  17. void *context = zmq_ctx_new ();
  18. void *subscriber = zmq_socket (context, ZMQ_SUB);
  19. int rc = zmq_connect (subscriber, "tcp://localhost:5556");
  20. assert (rc == 0);
  21. // Subscribe to zipcode, default is NYC, 10001
  22. const char *filter = (argc > 1)? argv [1]: "10001 ";
  23. rc = zmq_setsockopt (subscriber, ZMQ_SUBSCRIBE,
  24. filter, strlen (filter));
  25. assert (rc == 0);
  26. // Process 100 updates
  27. int update_nbr;
  28. long total_temp = 0;
  29. for (update_nbr = 0; update_nbr < 100; update_nbr++) {
  30. char buffer [256];
  31. int size = zmq_recv (subscriber, buffer, 255, 0);
  32. if (size == -1)
  33. continue;
  34. buffer[size] = '\0';
  35. int zipcode, temperature, relhumidity;
  36. sscanf (buffer, "%d %d %d",
  37. &zipcode, &temperature, &relhumidity);
  38. total_temp += temperature;
  39. }
  40. printf ("Average temperature for zipcode '%s' was %dF\n",
  41. filter, (int) (total_temp / update_nbr));
  42. zmq_close (subscriber);
  43. zmq_ctx_destroy (context);
  44. return 0;
  45. }

B.request-response模式：

server：

  1. #include <zmq.h>
  3. #include <stdio.h>
  4. #include <string.h>
  5. #include <assert.h>
  6. #if (!defined (WIN32))
  7. # include <sys/time.h>
  8. #endif
  9. #if (defined (WIN32))
  10. # include <windows.h>
  11. #endif
  12. int main (void)
  13. {
  14. // Socket to talk to clients
  15. void *context = zmq_ctx_new ();
  16. void *responder = zmq_socket (context, ZMQ_REP);
  17. int rc = zmq_bind (responder, "tcp://*:5555");
  18. assert (rc == 0);
  19. while (1) {
  20. char buffer [10];
  21. zmq_recv (responder, buffer, 10, 0);
  22. printf ("Received Hello\n");
  23. Sleep (1); // Do some 'work'
  24. zmq_send (responder, "World", 5, 0);
  25. }
  26. return 0;
  27. }


client:

  1. #include <zmq.h>
  2. #include <string.h>
  3. #include <stdio.h>
  4. int main (void)
  5. {
  6. printf ("Connecting to hello world server...\n");
  7. void *context = zmq_ctx_new ();
  8. void *requester = zmq_socket (context, ZMQ_REQ);
  9. zmq_connect (requester, "tcp://localhost:5555");
  10. int request_nbr;
  11. for (request_nbr = 0; request_nbr != 10; request_nbr++) {
  12. char buffer [10];
  13. printf ("Sending Hello %d...\n", request_nbr);
  14. zmq_send (requester, "Hello", 5, 0);
  15. zmq_recv (requester, buffer, 10, 0);
  16. printf ("Received World %d\n", request_nbr);
  17. }
  18. zmq_close (requester);
  19. zmq_ctx_destroy (context);
  20. return 0;
  21. }

C. ROUTER -DEALER模式
server端：

qyhzmqserverworker.h：
  1. #ifndef QYHZMQSERVERWORKER_H
  2. #define QYHZMQSERVERWORKER_H
  4. #include <zmq.hpp>
  6. class QyhZmqServerWorker
  7. {
  8. public:
  9. QyhZmqServerWorker(void *ctx);
  10. void work();
  11. private:
  12. zmq::context_t *ctx_;
  13. zmq::socket_t worker_;
  14. };
  16. #endif // QYHZMQSERVERWORKER_H

qyhzmqserverworker.cpp：
  1. #include "qyhzmqserverworker.h"
  3. QyhZmqServerWorker::QyhZmqServerWorker(void *ctx):
  4. ctx_((zmq::context_t *)ctx),
  5. worker_(*ctx_, ZMQ_REP)
  6. {
  8. }
  10. void QyhZmqServerWorker::work()
  11. {
  12. worker_.connect("inproc://workers");
  14. try {
  15. while (true) {
  16. zmq::message_t msg;
  17. zmq::message_t copied_msg;
  18. worker_.recv(&msg);
  19. //处理结尾没有\0的问题
  20. printf("recv:%s\n",std::string((char*)msg.data(),msg.size()).c_str());
  21. copied_msg.copy(&msg);
  22. worker_.send(copied_msg);
  23. }
  24. }
  25. catch (std::exception &e) {}
  26. }

qyhzmqserver.h：
  1. #ifndef QYHZMQSERVER_H
  2. #define QYHZMQSERVER_H
  4. #include <vector>
  5. #include <thread>
  6. #include <memory>
  7. #include <functional>
  9. #include <zmq.hpp>
  12. class QyhZmqServer
  13. {
  14. public:
  15. QyhZmqServer();
  17. //线程数量
  18. enum{ MAX_THREAD = 10 };
  20. //线程中初始化的入口
  21. void run();
  22. private:
  23. zmq::context_t ctx_;
  24. zmq::socket_t frontend_;
  25. zmq::socket_t backend_;
  26. };
  28. #endif // QYHZMQSERVER_H


qyhzmqserver.cpp：
  1. #include "qyhzmqserver.h"
  2. #include "qyhzmqserverworker.h"
  4. QyhZmqServer::QyhZmqServer():
  5. ctx_(1),
  6. frontend_(ctx_, ZMQ_ROUTER),
  7. backend_(ctx_, ZMQ_DEALER)
  8. {
  10. }
  12. void QyhZmqServer::run()
  13. {
  14. frontend_.bind("tcp://*:5555");
  15. backend_.bind("inproc://workers");
  17. std::vector<QyhZmqServerWorker *> worker;
  18. std::vector<std::thread *> worker_thread;
  20. for (int i = 0; i < MAX_THREAD; ++i)
  21. {
  22. //一个新的工人
  23. worker.push_back(new QyhZmqServerWorker((void *)&ctx_));
  25. //启动一个线程，执行这个工人的 work函数
  26. worker_thread.push_back(new std::thread(std::bind(&QyhZmqServerWorker::work, worker[i])));
  27. worker_thread[i]->detach();
  28. }
  30. //执行代理操作
  31. try {
  32. zmq::proxy(frontend_, backend_, nullptr);
  33. }
  34. catch (std::exception &e) {}
  36. for (int i = 0; i < MAX_THREAD; ++i) {
  37. delete worker[i];
  38. delete worker_thread[i];
  39. }
  40. }


main.cpp：
  1. #include "qyhzmqserver.h"
  3. int main(int argc, char *argv[])
  4. {
  5. QyhZmqServer server;
  6. std::thread t(std::bind(&QyhZmqServer::run, &server));
  7. t.detach();
  8. getchar();
  9. return 0;
  10. }

CLIENT端:
main.cpp:
  1. #include <vector>
  2. #include <thread>
  3. #include <memory>
  4. #include <functional>
  6. #include <zmq.hpp>
  7. #include "zhelpers.hpp"
  9. class client_task {
  10. public:
  11. client_task()
  12. : ctx_(1),
  13. client_socket_(ctx_, ZMQ_REQ)
  14. {}
  16. void start() {
  18. client_socket_.connect("tcp://localhost:5555");
  20. int timeout = 1000;
  21. zmq_setsockopt (client_socket_, ZMQ_RCVTIMEO, &timeout, sizeof(timeout));
  22. zmq_setsockopt (client_socket_, ZMQ_SNDTIMEO, &timeout, sizeof(timeout));
  24. int request_nbr = 0;
  26. //这里出现异常，就直接退出了线程!
  27. try {
  28. while (true) {
  29. std::stringstream ss;
  30. ss<<"request :"<< ++request_nbr;
  31. std::string data = ss.str();
  33. zmq::message_t s(data.c_str(),data.length());
  34. client_socket_.send(s);
  35. zmq::message_t m;
  36. client_socket_.recv(&m);
  37. printf("recv:%s\n",std::string((char *)m.data(),m.size()).c_str());
  38. Sleep(1000);
  39. }
  40. }
  41. catch (std::exception &e) {}
  43. }
  45. private:
  46. zmq::context_t ctx_;
  47. zmq::socket_t client_socket_;
  48. };
  50. int main (void)
  51. {
  52. client_task ct1;
  53. client_task ct2;
  54. client_task ct3;
  56. std::thread(std::bind(&client_task::start, &ct1)).detach();
  57. std::thread(std::bind(&client_task::start, &ct2)).detach();
  58. std::thread(std::bind(&client_task::start, &ct3)).detach();
  60. getchar();
  61. return 0;
  62. }

 
对subscriber的简单封装,以供大家参考。解决了多线程调用的问题，并且可以自由 开始停止。实现了优雅的启动停止。
qyhzmqsubscriber.h
  1. #ifndef QYHZMQSUBSCRIBER_H
  2. #define QYHZMQSUBSCRIBER_H
  4. #include <functional>
  5. #include <thread>
  6. #include <zmq.hpp>
  8. class QyhZmqSubscriber
  9. {
  10. public:
  11. //回调绑定
  12. typedef std::function<void (std::string)> QyhZmqSubscriberCallback;
  14. QyhZmqSubscriber(const std::string _url, QyhZmqSubscriberCallback _subcallback);
  15. ~QyhZmqSubscriber();
  17. //开始订阅
  18. void start();
  20. //停止订阅
  21. void stop();
  23. private:
  24. void messageloop();
  25. static void messagethread(void *arg);
  26. private:
  27. volatile bool isStop;
  28. std::thread msgThread;
  29. zmq::context_t* context;
  30. zmq::socket_t* subscriber;
  31. std::string url;
  32. QyhZmqSubscriberCallback subcallback;
  33. };
  35. #endif // QYHZMQSUBSCRIBER_H

qyhzmqsubscriber.cpp
  1. #include "qyhzmqsubscriber.h"
  2. #include "global.h"
  4. QyhZmqSubscriber::QyhZmqSubscriber(const std::string _url, QyhZmqSubscriberCallback _subcallback):
  5. url(_url),
  6. subcallback(_subcallback),
  7. isStop(true),
  8. context(NULL)
  9. {
  10. }
  12. QyhZmqSubscriber::~QyhZmqSubscriber()
  13. {
  14. stop();
  15. }
  17. //开始订阅
  18. void QyhZmqSubscriber::start()
  19. {
  20. if(!isStop)return ;//运行中
  21. isStop=false;
  22. msgThread = std::thread(&QyhZmqSubscriber::messagethread, this);
  23. }
  25. //停止订阅
  26. void QyhZmqSubscriber::stop()
  27. {
  28. if(isStop)return ;//已停止
  29. isStop = true;
  30. delete context;
  31. if(msgThread.joinable())
  32. msgThread.join();
  33. }
  35. void QyhZmqSubscriber::messagethread(void *arg)
  36. {
  37. ((QyhZmqSubscriber *)arg)->messageloop();
  38. }
  40. void QyhZmqSubscriber::messageloop()
  41. {
  42. //非停止订阅的状态
  43. context = new zmq::context_t(1);
  44. subscriber = new zmq::socket_t(*context,ZMQ_SUB);
  45. subscriber->connect(url);
  46. subscriber->setsockopt(ZMQ_SUBSCRIBE, "", 0);
  48. while(!isStop)
  49. {
  50. zmq::message_t message;
  51. try{
  52. subscriber->recv(&message);
  53. }catch(std::exception& e){
  54. //被终止时，会抛出异常
  55. }
  56. if(isStop)break;
  58. std::string str = std::string(static_cast<char*>(message.data()), message.size());
  59. if(subcallback==nullptr){
  60. continue;
  61. }else{
  62. subcallback(str);
  63. }
  64. }
  65. delete subscriber;
  66. }

main.cpp

  1. #include <iostream>
  2. #include "qyhzmqsubscriber.h"
  4. class LogSubscriber
  5. {
  6. public:
  7. LogSubscriber():sub(NULL)
  8. {
  10. }
  11. ~LogSubscriber()
  12. {
  13. if(sub){
  14. delete sub;
  15. sub = NULL;
  16. }
  17. }
  18. void init()
  19. {
  20. if(sub)
  21. {
  22. delete sub;
  23. sub = NULL;
  24. }
  26. //配置参数
  27. std::string url = "tcp://localhost:5555";
  28. QyhZmqSubscriber::QyhZmqSubscriberCallback subcallback = std::bind(&LogSubscriber::onSub, this, std::placeholders::_1);
  29. sub = new QyhZmqSubscriber(url,subcallback);
  30. }
  31. void startSub()
  32. {
  33. sub->start();
  34. }
  35. void stopSub()
  36. {
  37. sub->stop();
  38. }
  39. private:
  40. void onSub(std::string msg)
  41. {
  42. //your msg process
  43. std::cout<<msg<<std::endl;
  44. }
  45. private:
  46. QyhZmqSubscriber *sub;
  47. };
  50. int main(int argc, char const *argv[])
  51. {
  52. LogSubscriber logsub;
  53. logsub.init();
  54. bool quit = false;
  55. while(!quit){
  56. char c;
  57. std::cin>>c;
  58. switch(c){
  59. case 's':logsub.startSub();break;
  60. case 't':logsub.stopSub();break;
  61. case 'q':quit=true;break;
  62. }
  63. }
  64. return 0;
  65. }

运行结果截图


麦田or太阳
关注
zeroMq的使用
LJ2415的博客
01-14 1502
ZeroMQ简介: ZeroMQ是一种基于消息队列的多线程网络库.提供跨越多种传输协议(TCP:传输控制协议,当传输出现错误时,能自动予以纠正;UDP:用户数据包协议,当传输出现错误时会将错误信息丢弃;)的套接字,ZeroMQ是一个可伸缩层,可并行运行,分散在分布式系统间. zeroMQ在设计上主要采用了以下几个高能性的特征: 1.无锁的队列模型 2.批量处理的算法 3.多核下的线程绑定,无...
传输层的各种模式——ZeroMQ 库的使用
早晨的阳光 的技术博客
03-22 8129
最近在研究 ZeroMQ 库的使用，所以在这里总结一下各种模式，以便日后拿来使用。 关于 ZeroMQ 库，我就不多介绍了，大家可以参考下面一些文章，以及他的官网、使用指南、API 参考、项目仓库等内容。 开源点评：ZeroMQ简介 ZeroMQ的学习和研究 ZeroMQ 的模式 ZeroMQ 的目标是成为 OSI 模型的传输层(Transport Layer)的标准协议，所
ZeroMQ 使用指南（最新的版本）
11-25
ZeroMQ 使用指南，最新的版本，从入门到精通。支持请求应答、发布订阅等模式
ZeroMQ简单使用
jenie的专栏
05-04 520
安装命令 apt-getinstall libtool apt-get install autoconf apt-get install pkg-config 下载 ： wgethttps://github.com/zeromq/libzmq/releases/download/v4.3.2/zeromq-4.3.2.tar.gz 解压： tar xzfv zeromq-4.3.2.ta...
ZeroMQ 4.2.3 - 开源消息中间件库
weixin_28793831的博客
06-22 926
ZeroMQ (也称为 ØMQ, 0MQ 或 zinc) 是一个高效的通信库，它提供了套接字抽象层，可简化在进程、设备、网络之间进行消息传递的复杂性。它是开源的，采用LGPLv3许可协议，拥有跨平台和多语言支持的特点。零拷贝（Zero-Copy）是一种数据传输技术，它允许多个进程共享数据，而无需在内核空间和用户空间之间进行拷贝。在传统的数据传输过程中，数据在发送或接收时通常需要从用户空间拷贝到内核空间的缓冲区中，然后再从内核空间拷贝到目标位置。
ZeroMQ 使用（一）
zzbjut
10-20 8648
ZeroMQ简介
ZeroMQ用法
仙人Immortal的博客
09-24 257
ZeroMQ用法介绍在线安装源码安装Demo 介绍 号称最快消息队列 在线安装 Ubuntu/Debian/Mint apt-get install libczmq-dev Fedora dnf install czmq-devel OSX brew install czmq Windows #生成32位动态库 .\vcpkg.exe install czmq #生成65位静态库 .\vcpkg.exe install czmq:x64-windows-static 源码安装 直接cmake外部构建
ZMQ/ZeroMQ使用手册
07-06
你可以使用套接字构建多对多的连接模式，如扇出、 发布-订阅、任务分发、请求-应答等。ZMQ 的快速足以胜任集群应用产品。它 的异步 I/O 机制让你能够构建多核应用程序，完成异步消息处理任务。ZMQ 有 着多语言支持，...
ZeroMQ使用环境和结构详细分析
05-29
### ZeroMQ使用环境和结构详细分析 #### 一、ZeroMQ概述 ZeroMQ是一种高度灵活且功能强大的消息队列库，它将复杂的网络通信抽象化，使得开发人员能够轻松地构建分布式应用程序。ZeroMQ的核心设计理念是提供一种轻...
ZeroMQ使用介绍
11-18
### ZeroMQ使用介绍 #### 一、ZeroMQ简介 ZeroMQ（也称为0MQ）是一种高度灵活的消息传递库，它提供了高级别的抽象，使得开发者能够轻松地构建分布式或并发应用程序。ZeroMQ最初设计的目标是简化网络编程，并提供一...
ZeroMQ使用时会出现哪些问题
最新发布
07-23
嗯，用户现在想了解ZeroMQ使用过程中的常见问题和注意事项。之前已经详细讨论过ZeroMQ的四种核心模式（请求-响应、发布-订阅、管道、独占对等）和传输协议，看来用户正在深入实践阶段。 用户可能正在搭建分布式系统...
ZeroMQ使用教程
17岁boy的博客
03-05 6574
简介： ZeroMQ简称ZMQ，它对socket编程进行了封装，通俗的说，它就像一个框架一样，对socket lib进行了很好的封装，让socket编程变得更加简单。 ZMQ采用消息队列的方式对socket的包进行管理，它支持多线程，同时ZMQ是开源的，你可以在不同的Linux内核架构上缩减ZMQ模块，这在ARM嵌入式上非常有利。 ZMQ的明确目标是“成为标准网络协议栈的一部分，之后进入Linux内核”，目前还未成功。 ZMQ不是消息队列服务器，是一个基于消息队列模式的Socket库。 ZMQ的特
zeromq教程
06-27
ZeroMQ是一个很有个性的项目，它原来是定位为“史上最快消息队列”，所以名字里面有“MQ”两个字母，但是后来逐渐演变发展，慢慢淡化了消息队列的身影，改称为消息内核，或者消息层了。从网络通信的角度看，它处于会话层之上，应用层之下，有了它，你甚至不需要自己写一行的socket函数调用就能完成复杂的网络通信工作。
zeromq安装使用教程（最详细）
qq_44815020的博客
05-18 7344
zermq基本概念 zeromq用很多中编译使用的方法。直接使用vs编译（不建议使用，长时间未维护很多报错）vcpkg（包管理器下载) cmake（推荐） zeromq的适配好像和win10出现了问题，不知道是我系统的原因还是，折腾了几天之后还是在虚拟机上的win7系统下编译使用成功 下面总结一下安装的流程,安装之前我们要知道zeromq我们安装只是最底层的原生库Libzmq， zeromq 接口类型 其中在原生库Libzmq中衍生了很多中语言的高层次封装接口，读者根据需对应求选取使用 名称 接口类型 ur
zeromq的使用
weixin_33895604的博客
08-08 128
2019独角兽企业重金招聘Python工程师标准>>> ...
ZeroMQ使用汇总
weixin_33729196的博客
07-27 152
ZeroMQ，史上最快的消息队列 —– ZMQ的学习和研究  ZeroMQ 的模式 [架构] ZeroMQ 深度探索（一）  消息队列ZeroMQ     服务端使用流程： 　　 void* m_Context; void* m_sktMsgVideoFrame; m_sktMsgVideoFrame = zmq_socket(m_Context,ZMQ_PUB); int ret =...
ZeroMQ基础入门
顺其自然~专栏
08-13 6377
mq是消息队列（message queue）的简称，目前有多种消息队列可用，包括RabbitMQ、Kafka等，它们各有特色，可以结合具体的项目需求使用。 ZeroMQ简称Zmq，或者0mq，核心引擎由c++编写，是轻量级消息通信库，在对传统的标准socket接口扩展的基础上形成的特色消息通信中间件。 Zmq提供了异步消息队列的抽象，具有多种消息通信模式，能够实现消息过滤，能够无缝对接多种传输协议。 简言之，使用socket时，需要显式地建立连接、销毁连接、选择协议（TCP/UDP）和处理错误等，而Z
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值