C++ io_service::stop方法代码示例

int main( int argc, char **argv )
{
    // google::InitGoogleLogging(argv[0]);

    LOG(INFO) << "main thread " << THIS_THREAD_ID << " running...";

    // 如果没有，io_service 执行完了队列中所有缓存的job就退出，在getchar()之前terminating
    boost::asio::io_service::work io_work( std::ref(g_io_service) );

    boost::thread_group thrgrp;

    for (int i = 0; i < 5; ++i)
        thrgrp.create_thread( run_io_service );

    SLEEP_SECONDS(1);

    g_io_service.dispatch( std::bind(job_func, 1) );

    getchar();
    LOG(INFO) << "Trying to stop io_service...";

    // NOTE!!! 如果job_func里用dispatch就停不下来，嵌套
    g_io_service.stop();

    thrgrp.join_all();

    return 0;
}

/**
 * @brief Funkcia sa snazi co najbezpecnejsim sposobom ukoncit server v pripade nudze
 *
 * zastavuje celu sietovu vrstvu programu a uvolnuje pamat
 */
static void sighandler(int signum) 
{ 
    (void)signum;
    io_service.reset();
    io_service.stop();
    Manager::instance().Shutdown();
}

void ShutdownThreadPool(std::vector<std::thread>& threadPool)
{
    _ioService.stop();

    for (auto& thread : threadPool)
        thread.join();
}

    void freceive_more_async(boost::asio::io_service & ios, aziomq::socket & socket,
                             const const_buf_vec & expected_bufs, int flags) {
        SYNC_LOG(__PRETTY_FUNCTION__);
         //create vector of raw bufs to fill from length of expected_bufs
        buf_vec_t buf_vec(std::distance(std::begin(expected_bufs),
                                        std::end(expected_bufs)));
        zero(buf_vec);

         //create azio buffer vector
        mutable_buf_vec bufs;
        init(bufs, buf_vec);

        auto it = std::begin(bufs);
        auto e = std::end(bufs);

        std::exception_ptr err;
        socket.async_receive_more(boost::asio::buffer(*it++),
                [&ios, &socket, &bufs, &it, e, &err, expected_bufs](const boost::system::error_code & ec,
                                                                   aziomq::socket::more_result mr) {
                    if (ec) {
                        err = std::make_exception_ptr(boost::system::system_error(ec));
                    } else {
                        for (; mr.second && it != e; ++it) {
                            mr = socket.receive_more(boost::asio::buffer(*it));
                            err = check_res(bufs, expected_bufs);
                        }
                    }
                    ios.stop();
                });
        ios.run();
        if (err != std::exception_ptr())
            std::rethrow_exception(err);
    }

    void freceive_async(boost::asio::io_service & ios, aziomq::socket & socket,
                            const const_buf_vec & expected_bufs, int flags) {
        SYNC_LOG(__PRETTY_FUNCTION__);
         //create vector of raw bufs to fill from length of expected_bufs
        buf_vec_t buf_vec(std::distance(std::begin(expected_bufs),
                                        std::end(expected_bufs)));
        zero(buf_vec);

         //create azio buffer vector
        mutable_buf_vec bufs;
        init(bufs, buf_vec);

        std::exception_ptr err;
        socket.async_receive(bufs,
                [&ios, &bufs, &err, expected_bufs](const boost::system::error_code & ec, size_t bytes_transferred) {
                    if (ec) {
                        err = std::make_exception_ptr(boost::system::system_error(ec));
                    } else {
                        err = check_res(bufs, expected_bufs);
                    }
                    ios.stop();
                });
        ios.run();
        if (err != std::exception_ptr())
            std::rethrow_exception(err);
    }

BOOL CtrlHandler(DWORD fdwCtrlType)
{
	switch (fdwCtrlType)
	{
		// Handle the CTRL-C signal. 
	case CTRL_C_EVENT:
		printf("Ctrl-C event\n\n");
		Beep(750, 300);
		io_service.stop();
		return(TRUE);

		// CTRL-CLOSE: confirm that the user wants to exit. 
	case CTRL_CLOSE_EVENT:
		Beep(600, 200);
		printf("Ctrl-Close event\n\n");
		io_service.stop();
		return(TRUE);

		// Pass other signals to the next handler. 
	case CTRL_BREAK_EVENT:
		Beep(900, 200);
		printf("Ctrl-Break event\n\n");
		io_service.stop();
		return FALSE;

	case CTRL_LOGOFF_EVENT:
		Beep(1000, 200);
		printf("Ctrl-Logoff event\n\n");
		io_service.stop();
		return FALSE;

	case CTRL_SHUTDOWN_EVENT:
		Beep(750, 500);
		printf("Ctrl-Shutdown event\n\n");
		io_service.stop();
		return FALSE;

	default:
		return FALSE;
	}
	/*
	boost::asio::signal_set signals(io_service, SIGINT, SIGTERM);
	signals.async_wait(
		boost::bind(&boost::asio::io_service::stop, &io_service));//*/
}

void stopLogThread()
{
    if (LogThreadWork.get())
    {
        LogThreadWork.reset();
        LogIoService.stop();
        LogThread.try_join_for(boost::chrono::milliseconds(100));
    }
}

void subscribeHandler(boost::asio::io_service &ioService, const std::vector<char> &buf)
{
    std::string msg(buf.begin(), buf.end());

    std::cerr << "Message: " << msg << std::endl;

    if( msg == "stop" )
        ioService.stop();
}

void ShutdownThreadPool(std::vector<std::thread>& threadPool)
{
    sScriptMgr->OnNetworkStop();

    _ioService.stop();

    for (auto& thread : threadPool)
    {
        thread.join();
    }
}

 void fsend_async(boost::asio::io_service & ios, aziomq::socket & socket, const const_buf_vec & bufs, int flags) {
     SYNC_LOG(__PRETTY_FUNCTION__);
     std::exception_ptr err;
     socket.async_send(bufs,
             [&ios,&err](const boost::system::error_code & ec, size_t bytes_transferred) {
                 if (ec)
                     err = std::make_exception_ptr(boost::system::system_error(ec));
                 ios.stop();
             });
     ios.run();
     if (err != std::exception_ptr())
         std::rethrow_exception(err);
 }

void SignalHandler(const boost::system::error_code& error, int signalNumber)
{
    if (!error)
    {
        switch (signalNumber)
        {
        case SIGINT:
        case SIGTERM:
            _ioService.stop();
            break;
        }
    }
}

int main()
{
    boost::shared_ptr< boost::asio::io_service::work > work(new boost::asio::io_service::work(io_service));
    boost::thread_group worker_threads;
    Debug("Press [Enter] to exit.");
    for(int x = 0; x < 4;x++){
        worker_threads.create_thread(WorkerThread);
    }
    std::cin.get();
    io_service.stop();
    worker_threads.join_all();
    return 0;
}

inline void AsioThreadPool::stop()
{
    m_work.reset();

    m_io_svc.stop();

    for (auto &i : m_threads)
    {
        if (i.joinable())
        {
            i.join();
        }
    }
}

void read_images() {
    Frame* currentFrame;
    while (hasMoreFrames) {
        Frame* f = importer.next_frame();
        if (f) {
            in_buffer.push(f);
        }
        else {
            hasMoreFrames = false;
            ioService.stop();
        }
        boost::this_thread::sleep(boost::posix_time::milliseconds(30));
    }
}

int main(int argc, char** argv)
{
  if (2 > argc) {
    std::cout << "\nusage: " << argv[0] << " <term to track> [--full_screen]\n\n";
    return 1;
  }

  tw_term = argv[1];
  std::thread t1(setup_network_stream);

  draw_window(3 == argc);

  io_service.stop();
  t1.detach();

  return 0;
}