使用boost::thread来启动/停止记录数据(第二次更新)

我喜欢使用Boost Asio异步的东西

#include <iostream>
#include <fstream>
#include <boost/asio.hpp>
#include <boost/asio/signal_set.hpp>
#include <boost/asio/ip/tcp.hpp>
#include <boost/bind.hpp>
#include <boost/optional.hpp>
#include <thread>
using boost::asio::ip::tcp;
namespace asio = boost::asio;
struct program
{
    asio::io_service       _ioservice;
    asio::deadline_timer   _timer;
    asio::signal_set       _signals;
    std::array<char, 1024> _buffer;
    tcp::socket            _client;
    tcp::resolver          _resolver;
    std::ofstream          _logfile;
    std::thread            _thread;
    program() 
        : _timer(_ioservice),
        _signals(_ioservice),
        _client(_ioservice),
        _resolver(_ioservice)
    {
        do_connect(_resolver.resolve({ "localhost", "6767" }));
        do_toggle_logging_cycle();
        _signals.add(SIGINT);
        _signals.async_wait([this](boost::system::error_code ec, int) { if (!ec) close(); });
        _thread = std::thread(boost::bind(&asio::io_service::run, boost::ref(_ioservice)));
    }
    ~program()
    {
        if (_thread.joinable())
            _thread.join();
    }
    void close() {
        _ioservice.post([this]() { 
            _signals.cancel();
            _timer.cancel();
            _client.close(); 
        });
    }
private:
  void do_toggle_logging_cycle(boost::system::error_code ec = {})
  {
      if (ec != boost::asio::error::operation_aborted)
      {
          if (_logfile.is_open())
          {
              _logfile.close();
              _logfile.clear();
          } else
          {
              _logfile.open("/tmp/output.log");
          }
          _timer.expires_from_now(boost::posix_time::seconds(2));
          _timer.async_wait(boost::bind(&program::do_toggle_logging_cycle, this, boost::asio::placeholders::error()));
      } else 
      {
          std::cerr << "nDone, goobyen";
      }
  }
  void do_connect(tcp::resolver::iterator endpoint_iterator) {
      boost::asio::async_connect(
          _client, endpoint_iterator,
          [this](boost::system::error_code ec, tcp::resolver::iterator) {
                if (!ec) do_read();
                else     close();
          });
  }
  void do_read() {
    boost::asio::async_read(
        _client, asio::buffer(_buffer.data(), _buffer.size()),
        [this](boost::system::error_code ec, std::size_t length) {
            if (!ec) {
              if (_logfile.is_open())
              {
                    _logfile.write(_buffer.data(), length);
              }
              do_read();
            } else {
                close();
            }
    });
  }
};
int main()
{
    {
        program p; // does socket reading and (optional) logging on a separate thread
        std::cout << "nMain thread going to sleep for 15 seconds...n";
        std::this_thread::sleep_for(std::chrono::seconds(15));
        p.close(); // if the user doesn't press ^C, let's take the initiative
        std::cout << "nDestruction of program...n";
    }
    std::cout << "nMain thread endsn";
};

程序连接到本地主机的6767端口，并从该端口异步读取数据。

如果日志记录是活动的(_logfile.is_open())，所有接收到的数据都被写入/tmp/output.log。

• 读/写是在一个单独的线程上，但是所有的操作都是用_ioservice序列化的(参见close()中的post)
• 用户可以使用Ctrl+C终止套接字读取循环
• 每2秒，日志记录将被(取消)激活(见do_toggle_logging_cycle)

主线程在取消程序之前只休眠15秒(类似于用户按Ctrl-C)。