web-dev-qa-db-ja.com

Boostasioを使用したスレッドプール

Boost :: asioを使用して制限付きスレッドプールクラスを作成しようとしています。しかし、私はある時点で立ち往生していて、誰かが私を助けることができます。

唯一の問題は、カウンターを減らすべき場所ですか？

コードが期待どおりに機能しません。

問題は、スレッドがいつ実行を終了するのか、そしてスレッドがプールに戻ったことをどうやって知るのかわからないことです。

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

using namespace std;
using namespace boost;

class ThreadPool
{
    static int count;
    int NoOfThread;
    thread_group grp;
    mutex mutex_;
    asio::io_service io_service;
    int counter;
    stack<thread*> thStk ;

public:
    ThreadPool(int num)
    {   
        NoOfThread = num;
        counter = 0;
        mutex::scoped_lock lock(mutex_);

        if(count == 0)
            count++;
        else
            return;

        for(int i=0 ; i<num ; ++i)
        {
            thStk.Push(grp.create_thread(boost::bind(&asio::io_service::run, &io_service)));
        }
    }
    ~ThreadPool()
    {
        io_service.stop();
        grp.join_all();
    }

    thread* getThread()
    {
        if(counter > NoOfThread)
        {
            cout<<"run out of threads \n";
            return NULL;
        }

        counter++;
        thread* ptr = thStk.top();
        thStk.pop();
        return ptr;
    }
};
int ThreadPool::count = 0;


struct callable
{
    void operator()()
    {
        cout<<"some task for thread \n";
    }
};

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

    callable x;
    ThreadPool pool(10);
    thread* p = pool.getThread();
    cout<<p->get_id();

    //how i can assign some function to thread pointer ?
    //how i can return thread pointer after work done so i can add 
//it back to stack?


    return 0;
}
c++threadpoolboost-asio
20
vivek

つまり、ユーザーが提供したタスクを、次のような別の関数でラップする必要があります。

  • ユーザー関数または呼び出し可能オブジェクトを呼び出します。
  • ミューテックスをロックし、カウンターをデクリメントします。

このスレッドプールのすべての要件を理解していない可能性があります。したがって、明確にするために、ここに要件が何であると私が信じているかについての明確なリストがあります：

  • プールはスレッドの存続期間を管理します。ユーザーは、プール内にあるスレッドを削除できないようにする必要があります。
  • ユーザーは、邪魔にならない方法でタスクをプールに割り当てることができます。
  • タスクが割り当てられているときに、プール内のすべてのスレッドが現在他のタスクを実行している場合、そのタスクは破棄されます。

実装を提供する前に、強調したいいくつかの重要なポイントがあります。

  • スレッドが起動されると、完了、キャンセル、または終了するまで実行されます。スレッドが実行している機能を再割り当てすることはできません。単一のスレッドがその存続期間中に複数の関数を実行できるようにするために、スレッドはio_service::run()などのキューから読み取る関数で起動する必要があり、呼び出し可能な型がにポストされます。 io_service::post()などのイベントキュー。
  • io_service::run()は、_io_service_で保留中の作業がない場合、_io_service_が停止している場合、またはスレッドが実行されていたハンドラーから例外がスローされた場合に戻ります。未完了の作業がないときにio_serivce::run()が戻らないようにするために、_io_service::work_クラスを使用できます。
  • 型を要求する代わりに（つまり、タスクの型はobject()構文で呼び出すことができる必要があります）、タスクの型要件を定義すると（つまり、タスクはprocessから継承する必要があります）、ユーザーの柔軟性が高まります。これにより、ユーザーはタスクを関数ポインターまたはnullary operator()を提供する型として指定できます。

_boost::asio_を使用した実装：

_#include <boost/asio.hpp>
#include <boost/thread.hpp>

class thread_pool
{
private:
  boost::asio::io_service io_service_;
  boost::asio::io_service::work work_;
  boost::thread_group threads_;
  std::size_t available_;
  boost::mutex mutex_;
public:

  /// @brief Constructor.
  thread_pool( std::size_t pool_size )
    : work_( io_service_ ),
      available_( pool_size )
  {
    for ( std::size_t i = 0; i < pool_size; ++i )
    {
      threads_.create_thread( boost::bind( &boost::asio::io_service::run,
                                           &io_service_ ) );
    }
  }

  /// @brief Destructor.
  ~thread_pool()
  {
    // Force all threads to return from io_service::run().
    io_service_.stop();

    // Suppress all exceptions.
    try
    {
      threads_.join_all();
    }
    catch ( const std::exception& ) {}
  }

  /// @brief Adds a task to the thread pool if a thread is currently available.
  template < typename Task >
  void run_task( Task task )
  {
    boost::unique_lock< boost::mutex > lock( mutex_ );

    // If no threads are available, then return.
    if ( 0 == available_ ) return;

    // Decrement count, indicating thread is no longer available.
    --available_;

    // Post a wrapped task into the queue.
    io_service_.post( boost::bind( &thread_pool::wrap_task, this,
                                   boost::function< void() >( task ) ) );
  }

private:
  /// @brief Wrap a task so that the available count can be increased once
  ///        the user provided task has completed.
  void wrap_task( boost::function< void() > task )
  {
    // Run the user supplied task.
    try
    {
      task();
    }
    // Suppress all exceptions.
    catch ( const std::exception& ) {}

    // Task has finished, so increment count of available threads.
    boost::unique_lock< boost::mutex > lock( mutex_ );
    ++available_;
  }
};
_

実装に関するいくつかのコメント：

  • 例外処理は、ユーザーのタスクの周囲で発生する必要があります。ユーザーの関数または呼び出し可能オブジェクトがタイプ_boost::thread_interrupted_以外の例外をスローした場合、std::terminate()が呼び出されます。これは、Boost.Threadの スレッド関数の例外 動作の結果です。 Boost.Asioの ハンドラーからスローされた例外の影響 も読む価値があります。
  • ユーザーが_boost::bind_を介してtaskを提供した場合、ネストされた_boost::bind_はコンパイルに失敗します。次のいずれかのオプションが必要です：
    • _boost::bind_によって作成されたtaskはサポートされていません。
    • _boost::bind_は特定の関数オブジェクトでのみ正しく機能するため、_boost::protect_の結果が_boost::protect_を使用できる場合は、ユーザーのタイプに基づいてコンパイル時分岐を実行するメタプログラミング。
    • 別のタイプを使用して、taskオブジェクトを間接的に渡します。正確なタイプを失うという犠牲を払って、読みやすさのために_boost::function_を使用することを選択しました。 Boost.Asioの serialization の例に見られるように、_boost::Tuple_は少し読みにくくなりますが、正確な型を保持するために使用することもできます。

アプリケーションコードは、_thread_pool_タイプを非侵入的に使用できるようになりました。

_void work() {};

struct worker
{
  void operator()() {};
};

void more_work( int ) {};

int main()
{ 
  thread_pool pool( 2 );
  pool.run_task( work );                        // Function pointer.
  pool.run_task( worker() );                    // Callable object.
  pool.run_task( boost::bind( more_work, 5 ) ); // Callable object.
}
_

_thread_pool_は、Boost.Asioなしで作成でき、io_service::run()がいつ返されるかなど、_Boost.Asio_の動作について知る必要がなくなったため、メンテナにとっては少し簡単かもしれません。 _io_service::work_オブジェクトとは何ですか：

_#include <queue>
#include <boost/bind.hpp>
#include <boost/thread.hpp>

class thread_pool
{
private:
  std::queue< boost::function< void() > > tasks_;
  boost::thread_group threads_;
  std::size_t available_;
  boost::mutex mutex_;
  boost::condition_variable condition_;
  bool running_;
public:

  /// @brief Constructor.
  thread_pool( std::size_t pool_size )
    : available_( pool_size ),
      running_( true )
  {
    for ( std::size_t i = 0; i < pool_size; ++i )
    {
      threads_.create_thread( boost::bind( &thread_pool::pool_main, this ) ) ;
    }
  }

  /// @brief Destructor.
  ~thread_pool()
  {
    // Set running flag to false then notify all threads.
    {
      boost::unique_lock< boost::mutex > lock( mutex_ );
      running_ = false;
      condition_.notify_all();
    }

    try
    {
      threads_.join_all();
    }
    // Suppress all exceptions.
    catch ( const std::exception& ) {}
  }

  /// @brief Add task to the thread pool if a thread is currently available.
  template < typename Task >
  void run_task( Task task )
  {
    boost::unique_lock< boost::mutex > lock( mutex_ );

    // If no threads are available, then return.
    if ( 0 == available_ ) return;

    // Decrement count, indicating thread is no longer available.
    --available_;

    // Set task and signal condition variable so that a worker thread will
    // wake up andl use the task.
    tasks_.Push( boost::function< void() >( task ) );
    condition_.notify_one();
  }

private:
  /// @brief Entry point for pool threads.
  void pool_main()
  {
    while( running_ )
    {
      // Wait on condition variable while the task is empty and the pool is
      // still running.
      boost::unique_lock< boost::mutex > lock( mutex_ );
      while ( tasks_.empty() && running_ )
      {
        condition_.wait( lock );
      }
      // If pool is no longer running, break out.
      if ( !running_ ) break;

      // Copy task locally and remove from the queue.  This is done within
      // its own scope so that the task object is destructed immediately
      // after running the task.  This is useful in the event that the
      // function contains shared_ptr arguments bound via bind.
      {
        boost::function< void() > task = tasks_.front();
        tasks_.pop();

        lock.unlock();

        // Run the task.
        try
        {
          task();
        }
        // Suppress all exceptions.
        catch ( const std::exception& ) {}
      }

      // Task has finished, so increment count of available threads.
      lock.lock();
      ++available_;
    } // while running_
  }
};
_
36
Tanner Sansbury