ZMQ导致主线程冻结（或类似的东西......？）

时间：2018-03-06 22:48:31

标签： c++ multithreading zeromq

我有以下一段c ++代码，它打开一个ZMQ-subscriber-socket并以无限循环接收消息。

listener.cc :(代码应该可以使用，编译：{{1​​}}）

g++ -lzmq listener.cc

到目前为止，代码按预期工作：

#include <iostream>
#include <zmq.hpp>

class Listener {
public:
    Listener() {
        std::cout << "constructor call" << std::endl;

        // Not working:
//        zmq::context_t context(1);
//        sck = new zmq::socket_t(context, ZMQ_SUB);
//        sck->connect("tcp://127.0.0.1:9999");
//        sck->setsockopt( ZMQ_SUBSCRIBE, "", 0);

        std::cout << "constructor end" << std::endl;
    }

    void run() {
        // Ok:
        zmq::context_t context(1);
        sck = new zmq::socket_t(context, ZMQ_SUB);
        sck->connect("tcp://127.0.0.1:9999");
        sck->setsockopt(ZMQ_SUBSCRIBE, "", 0);

        while (1) { // Receive messages, not interesting:
            std::cout << "listening..." << std::endl;
            zmq::message_t message;
            sck->recv(&message);
            std::cout << "received something" << std::endl;
        }
    }
    zmq::socket_t *sck;
};

int main(int argc, char *argv[]) {
    Listener listener;
    std::cout << "foo" << std::endl;
    listener.run();
    return 0;
}

但是，我想将zmq-context / socket的初始化移动到类的构造函数中（注释掉的部分）。但是代码只是从构造函数调用中返回，构造函数中的所有语句都被执行但$ g++ -lzmq listener.cc $ ./a.out constructor call constructor end foo listening... 的第二行没有被执行而程序被卡住了。输出是：

main

我唯一想到的是主线程由于某种原因停止执行。任何人都可以解释这个并提供解决方案吗？

干杯

2 个答案:

答案 0 :(得分：2)

从构造函数中取出zmq::context_t context(1);。

应该在全球或类似的地方进行初始化。通常情况下，您只需要其中一个。

您正在冻结，因为您尝试删除构造函数本地的zmq::context_t，而套接字仍然存在且正在使用它。

答案 1 :(得分：1)

任何人都可以解释这个并提供解决方案吗？对两者都是......

ZeroMQ使用每个Context( nIOthreads = 1 )实例作为一个非常强大的引擎，并且必须小心谨慎，以便资源管理程序不会让人感到惊讶（因为阻塞/冻结就是这种情况）

如果存在一些活跃使用的套接字实例（在Context（） - 实例的引擎下管理），可能存在这样的情况，即在进入析构函数处理阶段之前并非所有传输都已完成或如果一个人手动执行类似的步骤，试图尝试.close()这样的socket-instance和/或.term() Context-instance。

人们知道或不知道，这很多次都是这样。

ZeroMQ本机API文档在这个主题上非常明确，并警告风险，尚未完成的低级别事务可能让一个人的代码无限期地等待外部（远程代理操作）事件，这将永远不会出现。这种不知不觉的代码看起来像是一个冻结/悬挂的失败，但只是因为没有意识到这种风险并没有采取适当的预防措施而被驱逐到这种确定性的情况。

虽然较新的API版本更改了一些默认设置，但我提倡所有用户明确设置安全配置，即使较新的默认设置可能会避免需要手动执行此操作。然而，这种做法有助于提高人们对在设计实践中应该考虑哪种碰撞的认识。

解决方案？始终.setsockopt( ZMQ_LINGER, 0 );

  

zmq_term() 将阻止，直到满足以下条件：

     

在上下文中打开的所有套接字都已使用zmq_close()关闭     对于上下文中的每个套接字，应用程序使用zmq_send()发送的所有消息都已物理传输到网络对等方，或者使用 ZMQ_LINGER 套接字选项设置的套接字延迟时间段已过期。

如上所述，这是每个套接字实例化的经验法则。

class Listener {
   // zmq::context_t aClassLocalCONTEXT;              // MAY GET SET LOCAL CTX BY VALUE
   // zmq::socket_t  aClassLocalSOCKET;               // MAY GET SET LOCAL SCK BY VALUE EITHER
      zmq::socket_t  *sck;

public:
    Listener() {
        std::cout << "constructor call" << std::endl;

     // zmq::context_t context(1);                    // not a best practice here
     // ---------------------------------------------------
     // sck = new zmq::socket_t( aClassLocalCONTEXT, ZMQ_SUB );
        sck = new zmq::socket_t( context, ZMQ_SUB );
        sck->setsockopt( ZMQ_LINGER, 0 );             // ALWAYS, best before .bind()/.connect()
        sck->connect(   "tcp://127.0.0.1:9999" );
        sck->setsockopt( ZMQ_SUBSCRIBE, "", 0 );
     // ----------------------------------------------// IF SETUP BY AN INSTANTIATION CALL INTERFACE
     // aClassLocalSOCKET->setsockopt( ZMQ_LINGER, 0 );
     // aClassLocalSOCKET->connect(    ... );
     // aClassLocalSOCKET->setsockopt( ZMQ_SUBSCRIBE, "", 0 );
     // ---------------------------------------------------
        std::cout << "constructor end" << std::endl;
    }
   ~Listener() {
        sck->close();                                 // A GOOD PRACTICE
     // ----------------------------------------------// IF SETUP BY AN INSTANTIATION CALL INTERFACE
     // aClassLocalSOCKET->close();
    }
    void run() {            
        while (1) {                                   // recv()-messages, not interesting:
            std::cout << "listening..." << std::endl;
            zmq::message_t message;
            sck->recv(&message);
            std::cout << "received something" << std::endl;
            zmq::zmq_msg_close(&message);             // A GOOD PLACE TO DISCARD A NEVER MORE USED RESOURCE
        }
    }
};


int main(int argc, char *argv[]) {
    zmq::context_t context(1);                        // GLOBAL CTX
    Listener listener;
    std::cout << "foo" << std::endl;
    listener.run();
    return 0;
}

高效资源可降低间接成本

资源的智能处理非常重要，因为每个实例化和销毁都会在[TIME] - 域和[SPACE] - 域（内存分配/解除分配成本，及时）中承担成本这些都很便宜。

另外一个人应该遵循ZeroMQ Zen of Zero - 不要分享任何东西（好吧，有时候共享一个Context（） - 实例是一种方式，但是......如果你认真考虑设计，最好阅读一本伟大的Pieter HINTJENS的书“Code Connected：Volume 1”，绝对值得花时间和努力。

相关问题
最新问题