c++ - 尽管有工作对象，asio::io_service.run() 仍退出

Question

我有一个调度程序类(下面删除了实现)，它创建一个 I/O 服务并允许启动工作线程来执行 io_service 处理程序。这些线程应该保持事件状态，直到我告诉它们停止。为此，我使用 io_service::work 对象。然而，尽管存在工作对象，这些线程不会保持事件状态。关于如何正确使用 io_service::work 有什么想法吗？

这是一个显示问题的最小工作示例(下面给出的DispatcherClass):

#include <boost/asio.hpp>
#include <boost/thread.hpp>

void myDispatcherMainThread(DispatcherClass &dispatcher)
{
    std::cout << "Dispatcher Started\n";
    dispatcher.AddCtrlCHandling();
    if (dispatcher.Run(2))
        std::cout << "Dispatcher is about to finish (expected).\n";
    else
        std::cout << "Dispatcher is about to finish (unexpected).\n";
}


int main(int argc, char* argv[]) {
    DispatcherClass dispatcher;
    boost::thread maindispatcherthread(myDispatcherMainThread,boost::ref(dispatcher));
    boost::this_thread::sleep(boost::posix_time::seconds(5));
    if (dispatcher.get_io_service().stopped())
        std::cout << "Dispatcher should not have finished!";

    dispatcher.cleanStop();
    maindispatcherthread.join();
}

这是调度程序类(放在这里是为了使这篇文章可读):

class DispatcherClass : private boost::noncopyable {
public:
    DispatcherClass():
      _ioService(),
      _pKeepWorking(new boost::asio::io_service::work( _ioService )),
      _expectingdispatchend(false){}

    boost::asio::io_service &get_io_service() { return _ioService; }

    // Start the dispatcher threads
    bool Run(unsigned int numThreads = -1)
    {
        // Recover after a clean stop
        if (!_pKeepWorking)
            _pKeepWorking.reset(new boost::asio::io_service::work( _ioService ));

        // Reset after clean or forced stop
        if (_ioService.stopped())
        {
            _expectingdispatchend = false;
            _ioService.reset();
        }

        // Start message dispatch threads
        boost::thread_group workerThreads;
        for (unsigned int i = 0; i < ((numThreads == (unsigned int)-1) ? (boost::thread::hardware_concurrency()) : numThreads); ++i)
            workerThreads.create_thread(boost::bind(&DispatcherClass::WorkerThread, this));

        // Wait until all threads finish
        workerThreads.join_all();

        return _expectingdispatchend;
    }

    // Stop the dispatcher threads
    void Stop()
    {
        _expectingdispatchend = true;
        _ioService.stop();
    }

    void cleanStop()
    {
        _expectingdispatchend = true;
        _pKeepWorking.reset();
    }

    // Stop the dispatcher threads on CTRL-C
    void AddCtrlCHandling()
    {
        boost::asio::signal_set sig_set(_ioService, SIGTERM, SIGINT);
        sig_set.async_wait(boost::bind(&boost::asio::io_service::stop, boost::ref(_ioService)));
    }

private:
    bool _expectingdispatchend;

    boost::asio::io_service _ioService;
    boost::shared_ptr< boost::asio::io_service::work > _pKeepWorking;

    void WorkerThread()
    {
        while (true) {
        try
        {
            boost::system::error_code ec;
            _ioService.run(ec);
            break;
        }
        catch (const std::exception &) {}
        }
    }
};

Answer 1

io_service::stop()正在取消的 SignalHandler 中调用，导致 io_service::run() 的所有调用尽快返回。

void DispatcherClass::AddCtrlCHandling()
{
    boost::asio::signal_set sig_set(...);
    sig_set.async_wait(boost::bind(
        &boost::asio::io_service::stop, boost::ref(_ioService)));
}

在DispatcherClass::AddCtrlCHandling()中，sig_set是一个类型为boost::asio::signal_set的自动变量。一旦函数返回，它的生命周期就结束了。在 signal_set 析构函数中，signal_set 上的所有未完成的异步等待操作都将完成，并返回错误代码 boost::asio::error::operation_aborted.因此，将调用 io_service::stop() 的 SignalHandler 会在 io_service 中排队并由其中一个工作线程调用。要解决此问题，请考虑通过将 sig_set 设为 DispatcherClass 的成员变量来延长 signal_set 的生命周期。