ZeroMQ的使用

最新推荐文章于 2025-06-25 13:34:28 发布
转载 最新推荐文章于 2025-06-25 13:34:28 发布 · 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 1505
ZeroMQ简介: ZeroMQ是一种基于消息队列的多线程网络库.提供跨越多种传输协议(TCP:传输控制协议,当传输出现错误时,能自动予以纠正;UDP:用户数据包协议,当传输出现错误时会将错误信息丢弃;)的套接字,ZeroMQ是一个可伸缩层,可并行运行,分散在分布式系统间. zeroMQ在设计上主要采用了以下几个高能性的特征: 1.无锁的队列模型 2.批量处理的算法 3.多核下的线程绑定,无...
传输层的各种模式——ZeroMQ 库的使用
早晨的阳光 的技术博客
03-22 8133
最近在研究 ZeroMQ 库的使用，所以在这里总结一下各种模式，以便日后拿来使用。 关于 ZeroMQ 库，我就不多介绍了，大家可以参考下面一些文章，以及他的官网、使用指南、API 参考、项目仓库等内容。 开源点评：ZeroMQ简介 ZeroMQ的学习和研究 ZeroMQ 的模式 ZeroMQ 的目标是成为 OSI 模型的传输层(Transport Layer)的标准协议，所
ZeroMQ 使用指南（最新的版本）
11-25
ZeroMQ 使用指南，最新的版本，从入门到精通。支持请求应答、发布订阅等模式
ZeroMQ简单使用
jenie的专栏
05-04 521
安装命令 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
2501_91751526的博客
06-25 819
ZeroMQ（也称为 ØMQ、0MQ 或 ZMQ）是一个，专为分布式系统和并发应用程序设计。它不是一个完整的消息队列系统（如 RabbitMQ/Kafka），而是一个，提供简洁的 API 实现进程间/网络间的消息传递。
ZeroMQ 使用（一）
zzbjut
10-20 8657
ZeroMQ简介
ZeroMQ用法
仙人Immortal的博客
09-24 258
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 6606
简介： 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 7365
zermq基本概念 zeromq用很多中编译使用的方法。直接使用vs编译（不建议使用，长时间未维护很多报错）vcpkg（包管理器下载) cmake（推荐） zeromq的适配好像和win10出现了问题，不知道是我系统的原因还是，折腾了几天之后还是在虚拟机上的win7系统下编译使用成功 下面总结一下安装的流程,安装之前我们要知道zeromq我们安装只是最底层的原生库Libzmq， zeromq 接口类型 其中在原生库Libzmq中衍生了很多中语言的高层次封装接口，读者根据需对应求选取使用 名称 接口类型 ur
zeromq的使用
weixin_33895604的博客
08-08 129
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 6395
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、付费专栏及课程。

余额充值