關於 boost 多執行緒（一）

在純 C++ 開發中，執行緒的建立由 pthread_create 函式實現。成功返回0，出錯返回 -1.其函式原型為：

int pthread_create(pthread_t *tidp,const pthread_attr_t *attr,(void*)(*start_rtn)(void*),void *arg);

呼叫該函式時需要傳入一個函式地址作為形參，該地址即為執行緒執行的入口。從建立的過程中可以看到，建立的同時綁定了執行緒任務（指定函式入口地址）。接下來只要 run 起來就可以了。對於多執行緒來說，boost 中有專門用來管理多個執行緒的 thread_group 類，它的作用相當於執行緒池。在 thread_group 的內部機制中，用 std::list <thread *>

class thread_group
    {
    private:
        thread_group(thread_group const&);
        thread_group& operator=(thread_group const&);
    public:
        thread_group() {}
        ~thread_group()
        {
            for(std::list<thread*>
 
::iterator it=threads.begin(),end=threads.end();
                it!=end;
                ++it)
            {
                delete *it;
            }
        }

        bool is_this_thread_in()
        {
            thread::id id = this_thread::get_id();
            boost::shared_lock<shared_mutex>
 
 guard(m);
            for(std::list<thread*>::iterator it=threads.begin(),end=threads.end();
                it!=end;
                ++it)
            {
              if ((*it)->get_id() == id)
                return true;
            }
            return false;
        }

        bool is_thread_in(thread* thrd)
        {
          if(thrd)
          {
            thread::id id = thrd->get_id();
            boost::shared_lock<shared_mutex> guard(m);
            for(std::list<thread*>::iterator it=threads.begin(),end=threads.end();
                it!=end;
                ++it)
            {
              if ((*it)->get_id() == id)
                return true;
            }
            return false;
          }
          else
          {
            return false;
          }
        }

        template<typename F>
        thread* create_thread(F threadfunc)
        {
            boost::lock_guard<shared_mutex> guard(m);
            std::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)
            {
                BOOST_THREAD_ASSERT_PRECONDITION( ! is_thread_in(thrd) ,
                    thread_resource_error(system::errc::resource_deadlock_would_occur, "boost::thread_group: trying to add a duplicated thread")
                );

                boost::lock_guard<shared_mutex> guard(m);
                threads.push_back(thrd);
            }
        }

        void remove_thread(thread* thrd)
        {
            boost::lock_guard<shared_mutex> guard(m);
            std::list<thread*>::iterator const it=std::find(threads.begin(),threads.end(),thrd);
            if(it!=threads.end())
            {
                threads.erase(it);
            }
        }

        void join_all()
        {
            BOOST_THREAD_ASSERT_PRECONDITION( ! is_this_thread_in() ,
                thread_resource_error(system::errc::resource_deadlock_would_occur, "boost::thread_group: trying joining itself")
            );
            boost::shared_lock<shared_mutex> guard(m);

            for(std::list<thread*>::iterator it=threads.begin(),end=threads.end();
                it!=end;
                ++it)
            {
              if ((*it)->joinable())
                (*it)->join();
            }
        }

#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
        void interrupt_all()
        {
            boost::shared_lock<shared_mutex> guard(m);

            for(std::list<thread*>::iterator it=threads.begin(),end=threads.end();
                it!=end;
                ++it)
            {
                (*it)->interrupt();
            }
        }
#endif

        size_t size() const
        {
            boost::shared_lock<shared_mutex> guard(m);
            return threads.size();
        }

    private:
        std::list<thread*> threads;
        mutable shared_mutex m;
    };

其建立過程與一般執行緒建立過程類似，由create_thread 函式實現：

for (std::size_t i = 0; i < thread_pool_size_; ++i) {
    thread_group_.create_thread(boost::bind(
                 &boost::asio::io_service::run, &io_service_));
}   

這裡將建立的每個執行緒都繫結在了 boost::asio::io_service io_service_ 上，並在建立成功後讓執行緒執行起來。用這種方式實現的多執行緒，必須先給予執行緒任務。否則，會導致執行緒空 run ，然後自動退出，只剩下主執行緒。（如果只是繫結函式，與 pthread_create 方式一致）。

gSystemUtil.m_download =  new CRemoteDownLoadClient (gSystemUtil.get_io_service(), Name, IP_Address, Port, Local_Dir_Path, Header);
gSystemUtil.m_download->Start(Start_Num, Nums);

上述這段程式碼相當於把繫結執行緒的 io_service_ 給了 CRemoteDownLoadClient 使用，把它貼上線上程池建立後，用這來驗證執行緒是否會退出。編譯後執行程式，用 ps 命令檢視應用程序的pid，然後用 top -H -p pid 監測該程序：

可以看到，只有pid為31948的主執行緒在執行。如果是正常執行的多執行緒程式，應該可以看到多個執行緒資訊：

如果想要用 thread_group 先創好執行緒，並在需要時再給予任務，可以使用 boost 中的boost::asio::io_service::work.在建立前人為給執行緒一個 work，這樣執行緒就不會空 run.至於執行緒在work時的資源佔用和損耗，一般可不計。