用std::thread替换实现boost::thread_group

thread_group是boost库中的线程池类，内部使用的是boost::thread。

随着C++ 11标准的制定和各大编译器的新版本的推出（其实主要是VS2012的推出啦……），本着能用标准库就用标准库的指导原则，决定把项目中多线程相关的部分代码从boost::thread迁移到std::thread。

thread的迁移本身很简单，毕竟stl的很多功能是直接从boost发展而来的，基本上就是改一下头文件和名称空间的问题，例外是thread_group，thread_group是boost的组件，但并不是标准库的组件，所以需要自己实现一下。

说是自己实现，其实就是复制粘贴boost中的代码啦。但boost中的thread_group使用shared_mutex来进行线程同步，shared_mutex也没有进入标准库，所以需要用什么东西来替代一下。shared_mutex没能进入标准库的原因就是C++标准化委员会认为目前可行的shared_mutex实现方案在性能上并不合算，不如直接使用mutex，既然如此，就直接用mutex吧。相应的shared_lock也修改成lock_guard，完成。

#include <thread>

#include <mutex>

#include <list>
#include <memory>
namespace std

{

    //兼容boost::thread_group

    //使用std::thread代替boost::thread,std::mutex代替boost::shared_mutex

    class thread_group

    {

    private:

        thread_group(thread_group const&);

        thread_group& operator=(thread_group const&);        

    public:

        thread_group() {}

        ~thread_group()

        {

            for(auto it=threads.begin(),end=threads.end();    it!=end;++it)

            {

                delete *it;

            }

        }



        template<typename F>

        thread* create_thread(F threadfunc)

        {

            lock_guard<mutex> guard(m);

            auto_ptr<thread> new_thread(new thread(threadfunc));

            threads.push_back(new_thread.get());

            return new_thread.release();

        }



        void add_thread(thread* thrd)

        {

            if(thrd)

            {

                lock_guard<mutex> guard(m);

                threads.push_back(thrd);

            }

        }



        void remove_thread(thread* thrd)

        {

            lock_guard<mutex> guard(m);

            auto it=std::find(threads.begin(),threads.end(),thrd);

            if(it!=threads.end())

            {

                threads.erase(it);

            }

        }



        void join_all()

        {

            lock_guard<mutex> guard(m);

            for(auto it=threads.begin(),end=threads.end();it!=end;++it)

            {

                (*it)->join();

            }

        }



        size_t size() const

        {

            lock_guard<mutex> guard(m);

            return threads.size();

        }



    private:

        list<thread*> threads;

        mutable mutex m;

    };

}

——其实完全没意义嘛……