SIGINT的优美关机

Question

我想处理来自内核的SIGINT信号，以便调用一个函数，该函数可以很好地关闭我的进程。

下面是一个工作示例，一个线程正在等待信号，然后调用函数handle_stop：

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

void handle_stop(const boost::system::error_code& error, int signal_number) {
    std::cout<<"Executing Safe Shutdown"<<std::cout;
    exit(0);
}

int main() {
    std::cout<<"Init"<<std::cout;
    boost::asio::io_service signalService;
    boost::asio::signal_set signals(signalService, SIGINT, SIGTERM, SIGQUIT);
    signals.async_wait(handle_stop);
    boost::thread signalThread(boost::bind(&boost::asio::io_service::run, &signalService));

    std::cout<<"Starting programm"<<std::cout;
    while (true) {
        std::cout<<"Waiting ctl-c"<<std::cout;
        sleep(1);
    }
}

我的目标是将线程和函数打包到类中，以调用关闭进程。

这里是一个不工作的尝试，进程立即关闭，而不等待信号。

怎么啦？

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

class Shutdown {
public:
      Shutdown():is_signal_received_ (false) {
              //signals_::remove();
              std::cout<<"constructor"<<std::endl;
      }
      ~Shutdown() {
      }

      void init() {
              std::cout<<"Init "<<std::endl;
              boost::asio::signal_set signals(signalService_, SIGINT, SIGTERM, SIGQUIT);
              signals.async_wait(boost::bind(boost::mem_fn(&Shutdown::handleStop), this, _1, _2));
              boost::thread signalThread(boost::bind(&boost::asio::io_service::run, &signalService_));
              std::cout<<"Init Completed"<<std::endl;
      }

      bool isSignalReceived() const {
              return is_signal_received_;
      }

private:
      std::atomic<bool> is_signal_received_;
      boost::asio::io_service signalService_;

      void handleStop(const boost::system::error_code& error, int signal_number) {
              is_signal_received_ = true;
              myHandleStop(error, signal_number);
      }

      virtual void myHandleStop(const boost::system::error_code& error, int signal_number) {
      }
};

class MyShutdown: public Shutdown {
private:
      void myHandleStop(const boost::system::error_code& error, int signal_number) {
              std::cout<<"Executing Safe Shutdown"<<std::cout;
              exit(0);
      }
};

int main() {
    MyShutdown safeShutdown;
    safeShutdown.init();
    while (true) {
        std::cout<<"Waiting ctl-c"<<std::cout;
        sleep(1);
    }
}

下面是编译的命令：

g++ -o main main.cpp -lpthread -l boost_thread -l boost_system --std=c++11

Answer 1

您的问题是，您的signal_set超出了范围，并在Shutdown::init的末尾被销毁。当发生这种情况时，async_wait将被取消。signalThread同时也超出了作用域，而不是detached或joined。它们都需要是类成员，这样它们才能存活，直到信号可以被处理为止：

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

class Shutdown {
public:
    Shutdown()
        : is_signal_received_ (false),
        signalService_(),
        signals_(signalService_, SIGINT, SIGTERM, SIGQUIT)
    {
        std::cout<<"constructor"<<std::endl;
    }
    ~Shutdown()
    {
        signals_.cancel();
        signalService_.stop();
        signalThread_.join();
    }

    void init() {
        std::cout<<"Init "<<std::endl;
        signals_.async_wait(boost::bind(&Shutdown::handleStop, this, _1, _2));
        signalThread_ = boost::thread(boost::bind(&boost::asio::io_service::run, &signalService_));
        std::cout<<"Init Completed"<<std::endl;
    }

    bool isSignalReceived() const {
        return is_signal_received_;
    }

private:
    std::atomic<bool> is_signal_received_;
    boost::asio::io_service signalService_;
    boost::thread signalThread_;
    boost::asio::signal_set signals_;

    void handleStop(const boost::system::error_code& error, int signal_number) {
        is_signal_received_ = true;
        myHandleStop(error, signal_number);
    }

    virtual void myHandleStop(const boost::system::error_code& error, int signal_number) {
    }
};

class MyShutdown: public Shutdown {
private:
    void myHandleStop(const boost::system::error_code& error, int signal_number) {
        std::cout<<"Executing Safe Shutdown"<<std::endl;
        exit(0);
    }
};

int main() {
    MyShutdown safeShutdown;
    safeShutdown.init();
    while (true) {
        std::cout<<"Waiting ctl-c"<<std::endl;
        sleep(10);
    }
}

我还添加了一些调用来关闭io_service和signal_set，并等待thread在~Shutdown中终止。