C++11：借助C++11特性简单高效实现线程池

难得有个半天的闲功法，在C++11下实现个简单的线程池模板。以前线程很麻烦，Windows/Linux代码不通用，需要借助boost库。但boost线程库做不到真正的header-only。好在C++11有了thread，mutex，条件变量，实现这样一个简单线程池可以做到简洁高效，客户端借助lamda用起来也很灵活。

客户端例子有空再给。

#ifndef _SIMPLE_THREAD_POOL_H
#define _SIMPLE_THREAD_POOL_H

#include <memory>
#include <deque>
#include <thread>
#include <mutex>
#include <sstream>
#include <condition_variable>

namespace util {

// SimpleDataQueue's get method returns immediately when queue is empty
template<class T>
struct SimpleDataQueue
{
    void Add(const T& data)
    {
        std::lock_guard<std::mutex> lock(queue_mutex_);
        queue_.push_back(data);
    }

    bool Get(T& data)
    {
        std::lock_guard<std::mutex> lock(queue_mutex_);
        if (queue_.empty()) {
            return false;
        }
        data = std::move(queue_.front());
        queue_.pop_front();
        return true;
    }

    size_t Size() const
    {
        std::lock_guard<std::mutex> lock(queue_mutex_);
        return queue_.size();
    }

    bool Empty() const
    {
        std::lock_guard<std::mutex> lock(queue_mutex_);
        return queue_.empty();
    }

private:
    std::deque<T> queue_;
    mutable std::mutex queue_mutex_;
};


// BlockingDataQueue's get method is blocked when queue is empty
template<class T>
struct BlockingDataQueue
{
    BlockingDataQueue()
    {}

    void Add(const T& data)
    {
        std::unique_lock<std::mutex> lock(queue_mutex_);
        queue_.push_back(data);
        lock.unlock();
        condition_var_.notify_one();
    }

    void Add(T&& data)
    {
        std::unique_lock<std::mutex> lock(queue_mutex_);
        queue_.push_back(data);
        lock.unlock();
        condition_var_.notify_one();
    }

    bool Get(T& data)
    {
        std::unique_lock<std::mutex> lock(queue_mutex_);
        if (!active_) {
            return false;
        }
        if (queue_.empty()) {
            condition_var_.wait(lock);
            if (!active_) {
                return false;
            }
        }
        data = std::move(queue_.front());
        queue_.pop_front();
        return true;
    }

    size_t Size() const
    {
        std::lock_guard<std::mutex> lock(queue_mutex_);
        return queue_.size();
    }

    bool Empty() const
    {
        std::lock_guard<std::mutex> lock(queue_mutex_);
        return queue_.empty();
    }

    // Destory the queue and notify all the wating threads to wake up
    void Destory()
    {
        std::unique_lock<std::mutex> lock(queue_mutex_);
        queue_.clear();
        active_ = false;
        lock.unlock();
        condition_var_.notify_all();
    }

private:
    std::deque<T> queue_;
    mutable std::mutex queue_mutex_;
    std::condition_variable condition_var_;
    bool active_ = {true};
};


class SimpleThreadPool
{
public:
    struct ThreadInfo
    {
        explicit ThreadInfo()
        {}

        explicit ThreadInfo(SimpleThreadPool* p_pool)
            : p_pool_(p_pool)
        {}

        std::string IdToStr() const
        {
            std::stringstream ss;
            ss << p_thread_->get_id();
            std::string str;
            ss >> str;
            return str;
        }

        const std::thread& GetThread() const
        {
            return *p_thread_;
        }

    private:
        std::shared_ptr<std::thread> p_thread_;
        SimpleThreadPool* p_pool_ = {};
        friend class SimpleThreadPool;
    };

public:
    explicit SimpleThreadPool(size_t thread_num)
    {
        for (size_t i = 0; i < thread_num; ++i) {
            threads_.push_back(ThreadInfo(this));
        }
    }

    template<class Function, class... Args>
    explicit SimpleThreadPool(size_t thread_num, Function&& f, Args&&... args)
    {
        for (size_t i = 0; i < thread_num; ++i) {
            threads_.push_back(ThreadInfo(this));
        }
        SetThreadFunction(std::forward<Function>(f), std::forward<Args>(args)...);
    }

    template<class Function, class... Args>
    void SetThreadFunction(Function&& f, Args&&... args)
    {
        for (auto& t : threads_) {
            t.p_thread_ = std::make_shared<std::thread>(
                std::forward<Function>(f), std::forward<Args>(args)...);
        }
    }

    void JoinAll()
    {
        for (auto& t : threads_) {
            t.p_thread_->join();
        }
    }

    size_t ThreadNum() const
    {
        return threads_.size();
    }

    // Get the pointer to ThreadInfo structure whose thread ID is the current thread ID.
    // Return nullptr if the current thread is not in the pool.
    const ThreadInfo* GetCurrentThreadInfo() const
    {
        for (auto& t : threads_) {
            if (t.p_thread_->get_id() == std::this_thread::get_id()) {
                return &t;
            }
        }
        return nullptr;
    }

private:
    std::vector<ThreadInfo> threads_;
};

}
#endif //_SIMPLE_THREAD_POOL_H