GroupBlog

首先我们先看signal_set.hpp，可以看到下面代码

#include <boost/asio/detail/config.hpp>
#include <boost/asio/basic_signal_set.hpp>

namespace boost {
namespace asio {

/// Typedef for the typical usage of a signal set.
typedef basic_signal_set<> signal_set;

} // namespace asio
} // namespace boost

显然，我们使用的signal_set实际上是一个基础模板类basic_signal_set<>
再次跳转basic_signal_set.hpp

构造函数

    explicit basic_signal_set(boost::asio::io_service& io_service) : basic_io_object<SignalSetService>(io_service)

    basic_signal_set(boost::asio::io_service& io_service, int signal_number_1)
    basic_signal_set(boost::asio::io_service& io_service, int signal_number_1, int signal_number_2)
    basic_signal_set(boost::asio::io_service& io_service, int signal_number_1, int signal_number_2, int signal_number_3) : basic_io_object<SignalSetService>(io_service)

显而易见，三个构造函数，都接受一个io_service和信号量的值，唯一区别就是信号量的数量不同。
一开始看到，奇怪为什么不弄个可变参数模板呢，不是更好，看到下面也就释然了，因为类signal_set已经提供了add函数来增加信号量，这里构造函数数量1~3只是为更方便而已，至于参数模板，实际是完全没有必要的。

为什么都要实现两种呢

两个函数：
add向集合中添加信号量
remove删除信号量

    void add(int signal_number)
    {
        boost::system::error_code ec;
        this->service.add(this->implementation, signal_number, ec);
        boost::asio::detail::throw_error(ec, "add");
    }
    boost::system::error_code add(int signal_number, boost::system::error_code& ec)
    {
        return this->service.add(this->implementation, signal_number, ec);
    }
    void remove(int signal_number)
    boost::system::error_code remove(int signal_number,
    boost::system::error_code& ec)

我们很容易发现，两个函数唯一的区别就是对错误的处理的方式b：错误码和异常抛出。
因此我们可以通过对错误码判断和捕获异常来进行错误处理。
我们的程序有同步和异步两种模式，在同步模式下，无论用哪种都可以，但在异步模式下，程序不会抛出异常，所以就只能使用错误码了。

清空和取消的区别

    void clear()
    boost::system::error_code clear(boost::system::error_code& ec)
    void cancel()
    boost::system::error_code cancel(boost::system::error_code& ec)

从字面意思我们很容易感觉到他们的区别，何谓清空，清空就是没有了，而取消不代表没有。(ps:光看命名就能猜的八九不离十的代码，可谓好代码)
仔细的看了代码：
clear: 清空(删除)集合中的所有信号量，并删除所有通知队列里的事件，如果集合本身为空，则抛出错误。
cancel:不改变集合中的信号量，向所有与信号有关的操作抛出错误码来终止其操作。

async_wait

template <typename SignalHandler>
BOOST_ASIO_INITFN_RESULT_TYPE(SignalHandler, void (boost::system::error_code, int))
async_wait(BOOST_ASIO_MOVE_ARG(SignalHandler) handler)
{
    // If you get an error on the following line it means that your handler does
    // not meet the documented type requirements for a SignalHandler.
    BOOST_ASIO_SIGNAL_HANDLER_CHECK(SignalHandler, handler) type_check;

    return this->service.async_wait(this->implementation, BOOST_ASIO_MOVE_CAST(SignalHandler)(handler));
}

这个函数很重要，因为我们对signal_set的主要使用要靠这个函数。
该函数接受一个 void (boost::system::error_code, int)) 类型的函数句柄，随后会在所监听的信号发生时调用此函数。
函数内部实现，只有两句话

BOOST_ASIO_SIGNAL_HANDLER_CHECK(SignalHandler, handler) type_check;

对函数进行类型检查，这个宏写的很复杂，看了好一会儿，坦白说，知晓其功能，但不明白每一句的意思，找时间要好好把这里钻个透。

return this->service.async_wait(this->implementation, BOOST_ASIO_MOVE_CAST(SignalHandler)(handler));

尾递归委托下层接口完成任务。

使用例子

//
//  main.cpp
//  AsioServer
//
//  Created by shiyi on 2016/12/10.
//  Copyright © 2016年 shiyi. All rights reserved.
//

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

using namespace boost;

void signal_handler(const boost::system::error_code& err, int signal)
{
    switch (signal) {
        case SIGINT:
            std::cout << "SIGNINT" << std::endl;
            break;
        case SIGTERM:
            std::cout << "SIGNTERM" << std::endl;
            break;
        default:
            break;
    }
}

int main(int argc, const char * argv[]) {

    asio::io_service service;

    asio::signal_set sigset(service, SIGINT, SIGTERM);
    sigset.async_wait(signal_handler);

    boost::system::error_code ec;
    service.run(ec);
    if(ec)
    {
        std::cout << boost::system::system_error(ec).what() << std::endl;
    }
    std::cout << "End" << std::endl;

}