worker_thread.hpp

Go to the documentation of this file.

#ifndef THREADPOOL_DETAIL_WORKER_THREAD_HPP_INCLUDED
#define THREADPOOL_DETAIL_WORKER_THREAD_HPP_INCLUDED


#include "scope_guard.hpp"

#include <boost/smart_ptr.hpp>
#include <boost/thread.hpp>
#include <boost/thread/exceptions.hpp>
#include <boost/thread/mutex.hpp>
#include <boost/bind.hpp>


namespace boost { namespace threadpool { namespace detail 
{

  template <typename Pool>
  class worker_thread
  : public enable_shared_from_this< worker_thread<Pool> > 
  , private noncopyable
  {
  public:
    typedef Pool pool_type;                

  private:
    shared_ptr<pool_type>      m_pool;     
    shared_ptr<boost::thread>  m_thread;   

    
    worker_thread(shared_ptr<pool_type> const & pool)
    : m_pool(pool)
    {
      assert(pool);
    }

        
        void died_unexpectedly()
        {
                m_pool->worker_died_unexpectedly(this->shared_from_this());
        }


  public:
          void run()
          { 
                  scope_guard notify_exception(bind(&worker_thread::died_unexpectedly, this));

                  while(m_pool->execute_task()) {}

                  notify_exception.disable();
                  m_pool->worker_destructed(this->shared_from_this());
          }


          void join()
          {
                  m_thread->join();
          }


          static void create_and_attach(shared_ptr<pool_type> const & pool)
          {
                  shared_ptr<worker_thread> worker(new worker_thread(pool));
                  if(worker)
                  {
                          worker->m_thread.reset(new boost::thread(bind(&worker_thread::run, worker)));
                  }
          }

  };


} } } // namespace boost::threadpool::detail

#endif // THREADPOOL_DETAIL_WORKER_THREAD_HPP_INCLUDED