ZeroMQ的使用

最新推荐文章于 2024-09-07 23:59:34 发布
最新推荐文章于 2024-09-07 23:59:34 发布
阅读量1k 收藏 4
点赞数

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 1327
ZeroMQ简介: ZeroMQ是一种基于消息队列的多线程网络库.提供跨越多种传输协议(TCP:传输控制协议,当传输出现错误时,能自动予以纠正;UDP:用户数据包协议,当传输出现错误时会将错误信息丢弃;)的套接字,ZeroMQ是一个可伸缩层,可并行运行,分散在分布式系统间. zeroMQ在设计上主要采用了以下几个高能性的特征: 1.无锁的队列模型 2.批量处理的算法 3.多核下的线程绑定,无...
ZeroMQ使用和结构详细分析
weixin_37779156的博客
10-30 841
** ZeroMQ使用和结构详细分析 ** 1 ZeroMQ 概述 　　　　ZeroMQ是一种基于消息队列的多线程网络库，其对套接字类型、连接处理、 帧、甚至路由的底层细节进行抽象，提供跨越多种传输协议的套接字。 ZeroMQ 是网络通信中新的一层，介于应用层和传输层之间（按照 TCP/IP划分），其是 一个可伸缩层，可并行运行，分散在分布式系统间。 2系统架构 2.1总体架构 　　　　ZeroM...
ZeroMQ 使用指南（最新的版本）
11-25
ZeroMQ 使用指南，最新的版本，从入门到精通。支持请求应答、发布订阅等模式
ZeroMQ简单使用
jenie的专栏
05-04 471
安装命令 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...
C++编程：ZeroMQ进程间(订阅-发布)通信配置优化
最新发布
Where there is life, there is hope.
09-07 973
ZeroMQ是适用于高性能的进程间通信（IPC）的中间件。本文将详细介绍几种优化ZeroMQ订阅-发布通信的方法，并通过代码示例展示如何在实际项目中应用。
ZeroMQ用法
仙人Immortal的博客
09-24 196
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外部构建
ZeroMQ使用教程
17岁boy的博客
03-05 5759
简介： ZeroMQ简称ZMQ，它对socket编程进行了封装，通俗的说，它就像一个框架一样，对socket lib进行了很好的封装，让socket编程变得更加简单。 ZMQ采用消息队列的方式对socket的包进行管理，它支持多线程，同时ZMQ是开源的，你可以在不同的Linux内核架构上缩减ZMQ模块，这在ARM嵌入式上非常有利。 ZMQ的明确目标是“成为标准网络协议栈的一部分，之后进入Linux内核”，目前还未成功。 ZMQ不是消息队列服务器，是一个基于消息队列模式的Socket库。 ZMQ的特
ZMQ/ZeroMQ使用手册
07-06
你可以使用套接字构建多对多的连接模式，如扇出、 发布-订阅、任务分发、请求-应答等。ZMQ 的快速足以胜任集群应用产品。它 的异步 I/O 机制让你能够构建多核应用程序，完成异步消息处理任务。ZMQ 有 着多语言支持，...
ZeroMQ使用环境和结构详细分析
05-29
### ZeroMQ使用环境和结构详细分析 #### 一、ZeroMQ概述 ZeroMQ是一种高度灵活且功能强大的消息队列库，它将复杂的网络通信抽象化，使得开发人员能够轻松地构建分布式应用程序。ZeroMQ的核心设计理念是提供一种轻...
ZeroMQ使用介绍
11-18
### ZeroMQ使用介绍 #### 一、ZeroMQ简介 ZeroMQ（也称为0MQ）是一种高度灵活的消息传递库，它提供了高级别的抽象，使得开发者能够轻松地构建分布式或并发应用程序。ZeroMQ最初设计的目标是简化网络编程，并提供一...
传输层的各种模式——ZeroMQ 库的使用
早晨的阳光 的技术博客
03-22 8002
最近在研究 ZeroMQ 库的使用，所以在这里总结一下各种模式，以便日后拿来使用。 关于 ZeroMQ 库，我就不多介绍了，大家可以参考下面一些文章，以及他的官网、使用指南、API 参考、项目仓库等内容。 开源点评：ZeroMQ简介 ZeroMQ的学习和研究 ZeroMQ 的模式 ZeroMQ 的目标是成为 OSI 模型的传输层(Transport Layer)的标准协议，所
Zmq使用实例多种语言C，C++,OC,Python等
01-25
zmq有多种语言实例，如：c、c++、OC、Python、c#等。本人受益匪浅，对有想学习zmq筒靴很有帮助哦
【Java】消息队列——ZeroMQ（ZMQ、0MQ）概述和使用演示
欢迎。
05-19 5487
ZeroMQ是一个开源的通信库，它通过sockets API来提供一个简单的消息传递模式。ZeroMQ内部实现了一种高效的网络消息传递机制，可以在多线程或多进程的环境中高效地进行消息传递，同时具有低延迟和高吞吐量的特点。高性能：ZeroMQ可以通过更少的数据传输实现更多的并发请求和响应，减少了网络负载，并提高了网络传输的效率。简单易用：ZeroMQ的API接口非常简单，易于使用和部署。跨平台：ZeroMQ可用于Windows、Linux、Mac OS X等多种操作系统和编程环境。
zeromq安装使用教程（最详细）
qq_44815020的博客
05-18 6564
zermq基本概念 zeromq用很多中编译使用的方法。直接使用vs编译（不建议使用，长时间未维护很多报错）vcpkg（包管理器下载) cmake（推荐） zeromq的适配好像和win10出现了问题，不知道是我系统的原因还是，折腾了几天之后还是在虚拟机上的win7系统下编译使用成功 下面总结一下安装的流程,安装之前我们要知道zeromq我们安装只是最底层的原生库Libzmq， zeromq 接口类型 其中在原生库Libzmq中衍生了很多中语言的高层次封装接口，读者根据需对应求选取使用 名称 接口类型 ur
zeromq的使用
qinyinghao的专栏
01-08 4476
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 ..
ZeroMQ使用汇总
weixin_33729196的博客
07-27 122
ZeroMQ，史上最快的消息队列 —– ZMQ的学习和研究  ZeroMQ 的模式 [架构] ZeroMQ 深度探索（一）  消息队列ZeroMQ     服务端使用流程： 　　 void* m_Context; void* m_sktMsgVideoFrame; m_sktMsgVideoFrame = zmq_socket(m_Context,ZMQ_PUB); int ret =...
zeromq ipc使用实例
05-18
在Linux上，可以使用以下命令安装ZeroMQ库： ```bash sudo apt-get install libzmq3-dev ``` 2. 创建一个发送者 ```python import zmq context = zmq.Context() # 创建一个ZMQ的socket socket = context.socket...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值