zeromq的使用

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:

#include <zmq.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <time.h>
#if (!defined (WIN32))
#   include <sys/time.h>
#endif
#if (defined (WIN32))
#   include <windows.h>
#endif
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
    srand((unsigned) time (NULL));
    while (1) {
        //  Get values that will fool the boss
        int zipcode, temperature, relhumidity;
        zipcode     = rand()%(100000);
        temperature = rand()%(215) - 80;
        relhumidity = rand()%(50) + 10;
        //  Send message to all subscribers
        char update [20];
        sprintf (update, "%05d %d %d", zipcode, temperature, relhumidity);
        zmq_send (publisher, update, strlen (update), 0);
    }
    zmq_close (publisher);
    zmq_ctx_destroy (context);
    return 0;
}

 

client:

#include <zmq.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <time.h>
#if (!defined (WIN32))
#   include <sys/time.h>
#endif
#if (defined (WIN32))
#   include <windows.h>
#endif
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);
    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 ";
    rc = zmq_setsockopt (subscriber, ZMQ_SUBSCRIBE,
                         filter, strlen (filter));
    assert (rc == 0);
    //  Process 100 updates
    int update_nbr;
    long total_temp = 0;
    for (update_nbr = 0; update_nbr < 100; update_nbr++) {
        char buffer [256];
        int size = zmq_recv (subscriber, buffer, 255, 0);
        if (size == -1)
            continue;
        buffer[size] = '\0';
        int zipcode, temperature, relhumidity;
        sscanf (buffer, "%d %d %d",
            &zipcode, &temperature, &relhumidity);
        total_temp += temperature;
    }
    printf ("Average temperature for zipcode '%s' was %dF\n",
        filter, (int) (total_temp / update_nbr));
    zmq_close (subscriber);
    zmq_ctx_destroy (context);
    return 0;
}

B.request-response模式：

server：

#include <zmq.h>

#include <stdio.h>
#include <string.h>
#include <assert.h>
#if (!defined (WIN32))
#   include <sys/time.h>
#endif
#if (defined (WIN32))
#   include <windows.h>
#endif
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];
        zmq_recv (responder, buffer, 10, 0);
        printf ("Received Hello\n");
        Sleep (1);          //  Do some 'work'
        zmq_send (responder, "World", 5, 0);
    }
    return 0;
}

 

client:

#include <zmq.h>
#include <string.h>
#include <stdio.h>
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;
    for (request_nbr = 0; request_nbr != 10; request_nbr++) {
        char buffer [10];
        printf ("Sending Hello %d...\n", request_nbr);
        zmq_send (requester, "Hello", 5, 0);
        zmq_recv (requester, buffer, 10, 0);
        printf ("Received World %d\n", request_nbr);
    }
    zmq_close (requester);
    zmq_ctx_destroy (context);
    return 0;
}

C. ROUTER -DEALER模式
server端：

qyhzmqserverworker.h：

#ifndef QYHZMQSERVERWORKER_H
#define QYHZMQSERVERWORKER_H

#include <zmq.hpp>

class QyhZmqServerWorker
{
public:
    QyhZmqServerWorker(void *ctx);
    void work();
private:
    zmq::context_t *ctx_;
    zmq::socket_t worker_;
};

#endif // QYHZMQSERVERWORKER_H

qyhzmqserverworker.cpp：

#include "qyhzmqserverworker.h"

QyhZmqServerWorker::QyhZmqServerWorker(void *ctx):
    ctx_((zmq::context_t *)ctx),
    worker_(*ctx_, ZMQ_REP)
{

}

void QyhZmqServerWorker::work()
{
    worker_.connect("inproc://workers");

    try {
        while (true) {
            zmq::message_t msg;
            zmq::message_t copied_msg;
            worker_.recv(&msg);
            //处理结尾没有\0的问题
            printf("recv:%s\n",std::string((char*)msg.data(),msg.size()).c_str());
            copied_msg.copy(&msg);
            worker_.send(copied_msg);
        }
    }
    catch (std::exception &e) {}
}

qyhzmqserver.h：

#ifndef QYHZMQSERVER_H
#define QYHZMQSERVER_H

#include <vector>
#include <thread>
#include <memory>
#include <functional>

#include <zmq.hpp>

class QyhZmqServer
{
public:
    QyhZmqServer();

    //线程数量
    enum{ MAX_THREAD = 10 };

    //线程中初始化的入口
    void run();
private:
    zmq::context_t ctx_;
    zmq::socket_t frontend_;
    zmq::socket_t backend_;
};

#endif // QYHZMQSERVER_H

 

qyhzmqserver.cpp：

#include "qyhzmqserver.h"
#include "qyhzmqserverworker.h"

QyhZmqServer::QyhZmqServer():
    ctx_(1),
    frontend_(ctx_, ZMQ_ROUTER),
    backend_(ctx_, ZMQ_DEALER)
{

}

void QyhZmqServer::run()
{
    frontend_.bind("tcp://*:5555");
    backend_.bind("inproc://workers");

    std::vector<QyhZmqServerWorker *> worker;
    std::vector<std::thread *> worker_thread;

    for (int i = 0; i < MAX_THREAD; ++i)
    {
        //一个新的工人
        worker.push_back(new QyhZmqServerWorker((void *)&ctx_));

        //启动一个线程，执行这个工人的 work函数
        worker_thread.push_back(new std::thread(std::bind(&QyhZmqServerWorker::work, worker[i])));
        worker_thread[i]->detach();
    }

    //执行代理操作
    try {
        zmq::proxy(frontend_, backend_, nullptr);
    }
    catch (std::exception &e) {}

    for (int i = 0; i < MAX_THREAD; ++i) {
        delete worker[i];
        delete worker_thread[i];
    }
}

 

main.cpp：

#include "qyhzmqserver.h"

int main(int argc, char *argv[])
{
    QyhZmqServer server;
    std::thread t(std::bind(&QyhZmqServer::run, &server));
    t.detach();
    getchar();
    return 0;
}

 

CLIENT端:
main.cpp:

#include <vector>
#include <thread>
#include <memory>
#include <functional>

#include <zmq.hpp>
#include "zhelpers.hpp"

class client_task {
public:
    client_task()
        : ctx_(1),
          client_socket_(ctx_, ZMQ_REQ)
    {}

    void start() {

        client_socket_.connect("tcp://localhost:5555");

        int timeout = 1000;
        zmq_setsockopt (client_socket_, ZMQ_RCVTIMEO, &timeout, sizeof(timeout));
        zmq_setsockopt (client_socket_, ZMQ_SNDTIMEO, &timeout, sizeof(timeout));

        int request_nbr = 0;

        //这里出现异常，就直接退出了线程!
        try {
            while (true) {
                std::stringstream ss;
                ss<<"request :"<< ++request_nbr;
                std::string data = ss.str();

                zmq::message_t s(data.c_str(),data.length());
                client_socket_.send(s);
                zmq::message_t m;
                client_socket_.recv(&m);
                printf("recv:%s\n",std::string((char *)m.data(),m.size()).c_str());
                Sleep(1000);
            }
        }
        catch (std::exception &e) {}

    }

private:
    zmq::context_t ctx_;
    zmq::socket_t client_socket_;
};

int main (void)
{
    client_task ct1;
    client_task ct2;
    client_task ct3;

    std::thread(std::bind(&client_task::start, &ct1)).detach();
    std::thread(std::bind(&client_task::start, &ct2)).detach();
    std::thread(std::bind(&client_task::start, &ct3)).detach();

    getchar();
    return 0;
}

 
对subscriber的简单封装,以供大家参考。解决了多线程调用的问题，并且可以自由 开始停止。实现了优雅的启动停止。
qyhzmqsubscriber.h

#ifndef QYHZMQSUBSCRIBER_H
#define QYHZMQSUBSCRIBER_H

#include <functional>
#include <thread>
#include <zmq.hpp>

class QyhZmqSubscriber
{
public:
    //回调绑定
    typedef std::function<void (std::string)> QyhZmqSubscriberCallback;

    QyhZmqSubscriber(const std::string _url, QyhZmqSubscriberCallback _subcallback);
    ~QyhZmqSubscriber();

    //开始订阅
    void start();

    //停止订阅
    void stop();

private:
    void messageloop();
    static void messagethread(void *arg);
private:
    volatile bool isStop;
    std::thread msgThread;
    zmq::context_t* context;
    zmq::socket_t* subscriber;
    std::string url;
    QyhZmqSubscriberCallback subcallback;
};

#endif // QYHZMQSUBSCRIBER_H

qyhzmqsubscriber.cpp

#include "qyhzmqsubscriber.h"
#include "global.h"

QyhZmqSubscriber::QyhZmqSubscriber(const std::string _url, QyhZmqSubscriberCallback _subcallback):
    url(_url),
    subcallback(_subcallback),
    isStop(true),
    context(NULL)
{
}

QyhZmqSubscriber::~QyhZmqSubscriber()
{
    stop();
}

//开始订阅
void QyhZmqSubscriber::start()
{
    if(!isStop)return ;//运行中
    isStop=false;
    msgThread = std::thread(&QyhZmqSubscriber::messagethread, this);
}

//停止订阅
void QyhZmqSubscriber::stop()
{
    if(isStop)return ;//已停止
    isStop = true;
    delete context;
    if(msgThread.joinable())
        msgThread.join();
}

void QyhZmqSubscriber::messagethread(void *arg)
{
    ((QyhZmqSubscriber *)arg)->messageloop();
}

void QyhZmqSubscriber::messageloop()
{
    //非停止订阅的状态
    context = new zmq::context_t(1);
    subscriber = new zmq::socket_t(*context,ZMQ_SUB);
    subscriber->connect(url);
    subscriber->setsockopt(ZMQ_SUBSCRIBE, "", 0);

    while(!isStop)
    {
        zmq::message_t message;
        try{
            subscriber->recv(&message);
        }catch(std::exception& e){
            //被终止时，会抛出异常
        }
        if(isStop)break;

        std::string str = std::string(static_cast<char*>(message.data()), message.size());
        if(subcallback==nullptr){
            continue;
        }else{
            subcallback(str);
        }
    }
    delete subscriber;
}

main.cpp

#include <iostream>
#include "qyhzmqsubscriber.h"

class LogSubscriber
{
public:
    LogSubscriber():sub(NULL)
    {

    }
    ~LogSubscriber()
    {
        if(sub){
            delete sub;
            sub = NULL;
        }
    }
    void init()
    {
        if(sub)
        {
            delete sub;
            sub = NULL;
        }

        //配置参数
        std::string url = "tcp://localhost:5555";
        QyhZmqSubscriber::QyhZmqSubscriberCallback subcallback = std::bind(&LogSubscriber::onSub, this, std::placeholders::_1);
        sub = new QyhZmqSubscriber(url,subcallback);
    }
    void startSub()
    {
        sub->start();
    }
    void stopSub()
    {
        sub->stop();
    }
private:
    void onSub(std::string msg)
    {
        //your msg process
        std::cout<<msg<<std::endl;
    }
private:
    QyhZmqSubscriber *sub;
};

int main(int argc, char const *argv[])
{
    LogSubscriber logsub;
    logsub.init();
    bool quit = false;
    while(!quit){
        char c;
        std::cin>>c;
        switch(c){
        case 's':logsub.startSub();break;
        case 't':logsub.stopSub();break;
        case 'q':quit=true;break;
        }
    }
    return 0;
}

运行结果截图

 
---------------------  
作者：jsqinyinghao  
来源：优快云  
原文：https://blog.youkuaiyun.com/qinyinghao/article/details/79000977?utm_source=copy  
版权声明：本文为博主原创文章，转载请附上博文链接！