thread_1 - Roast+ Wiki - Roast+

thread

今んとこWindowsだけ :b

宣言

ヘッダーファイル：roast/thread.hpp

 typedef int (*roast_thread_callback_t)(int);
 
 namespace roast
 {
         class thread_exception : public ::std::string
         {
         public:
                 thread_exception(const char* msg) : ::std::string(msg) {}
                 thread_exception(const ::std::string &s) : ::std::string(s) {}
         };
 
         template <typename _Impl>
         class thread_
         {
         public:
                 thread_();
                 thread_(roast_thread_func_t func, int param=0, void* opt=NULL);
                 template <typename T> thread_(const T &cls, int param=0, void* opt=NULL);
                 template <typename T> thread_(T *ptr, int param=0, void* opt=NULL);
                 template <typename T> thread_(int (T::*func)(int), T *ptr, int param=0, void* opt=NULL);
 
                 bool start_func(roast_thread_func_t func, int param=0, void* opt=NULL);
                 template <typename T> bool start_class(const T &cls, int param=0, void* opt=NULL);
                 template <typename T> bool start_class_ptr(T *ptr, int param=0, void* opt=NULL);
                 template <typename T> bool start_class_ptr(int (T::*func)(int), T *ptr, int param=0, void* opt=NULL);
 
                 bool start(roast_thread_func_t func, int param=0, void* opt=NULL);
                 template <typename T> bool start(const T &cls, int param=0, void* opt=NULL);
                 template <typename T> bool start(T *ptr, int param=0, void* opt=NULL);
                 template <typename T> bool start(int (T::*func)(int), T *ptr, int param=0, void* opt=NULL);
 
                 bool release();
                 bool join(unsigned int timeout_ms=-1);
                 bool is_alive();
                 int get_result();
                 
                 void* get_native_handle();
         };
         
 #ifdef WIN32
         typedef thread_< _thread_impl_win32> thread;
 #endif//WIN32
 }

使い方

 ::roast::thread hoge_thread(any_func);

のようにする事により、関数 any_func() をコールバック関数として使用したスレッドを起動します。
コールバック関数の型は

 typedef int (*roast_thread_callback_t)(int);

としてtypedefされており、一つのint型引数を取り、intを復帰する関数（ないしそれに相当する関数をキャストしたもの）である必要があります。

このコールバック関数のint型引数には、上記例では0が渡されますが

 roast::thread hoge_thread(any_func,10);

のように、第二パラメータを指定する事により、第二パラメータの値が渡されるようになります。（上記例では10）
複数のパラメータを渡したい場合には、それらを構造体化し、ポインタを渡すようにします。

引数なしコンストラクタを用いたい場合（startメソッド）

引数なしコンストラクタを用いたい場合は、

 roast::thread hoge_thread;
 hoge_thread.start(any_func,10);

のように、start()メソッドを使用します。

スレッドの終了待ち

 hoge_thread.join(1000);

join()メソッドを使用することにより、スレッドの終了を待機する事が出来ます。
引数として指定しているのは、終了待ちのタイムアウト時間（ミリ秒）です。
省略、または-1を指定した場合には無限に待ちます。

タイムアウト時間を経過してもスレッドが終了しなかった場合（及びもしくは何らかのエラーが有った場合）、join()メソッドはfalseを返します。
タイムアウト時間内にスレッドが終了した場合にはtrueを返します。

スレッドの生存状態の取得

スレッドの生存状態（コールバック関数が既に終了状態にあるかどうか）を取得するには、is_alive()メソッドを使用します。
is_alive()メソッドは、スレッドがまだ生存状態にある場合にはtrueを、終了している場合にはfalseを返します。

コールバック関数の復帰値の取得

get_result()メソッドを使用することにより取得できます。

クラス内メソッドの起動（staticメソッド）

 class CHoge
 {
 public:
         static int Hoge(int b)
         {
                 return printf("%d\n", b);
         }
 };
 
 void main( void )
 {
         roast::thread th(CHoge::Hoge,10);
         th.join();
 }

のようにすれば、クラス内のstaticメソッドを起動する事も可能です。

クラス内メソッドの起動（非staticメソッド）

メソッドが非staticである場合、第二引数としてそのクラスのインスタンスへのポインタを指定する必要があります。

 class CHoge
 {
 public:
         int m_a;
         CHoge(int a){ m_a = a; }
 
         int Hoge(int)
         {
                 return printf("%d\n", m_a);
         }
 };
 
 void main( void )
 {
         CHoge(10) hoge;
         roast::thread a(&CHoge::Hoge, &hoge);
         a.join();
 }

またコンパイラによっては上記の第一引数のように、メンバ関数ポインタへの&の付加が求められる場合もあります。

クラス内メソッドの起動（関数オブジェクト）

関数の代わりに関数オブジェクトを指定する事も出来ます。

 class CHoge
 {
 public:
         int m_a;
         CHoge(int a){ m_a = a; }
 
         int operator()(int)
         {
                 return printf("%d\n", m_a);
         }
 };
 
 void main( void )
 {
         roast::thread a(CHoge(10));
         a.join();
 }

また、同様のstartメソッドによる起動や、引数指定も可能です。

 #include "roast/thread.hpp"
 class CHoge
 {
 public:
         int m_a;
         CHoge(int a){ m_a = a; }
 
         int operator()(int b)
         {
                 return printf("%d + %d = %d\n", m_a, b, m_a + b);
         }
 };
 
 void main( void )
 {
         roast::thread a;
         a.start(CHoge(10),20);
         a.join();
 }

コンストラクタ、及びstartメソッドの第一引数として渡された関数オブジェクトは コピーコンストラクタにより内部的にコピーされたものが使用されます。

このため、パフォーマンスの問題や、コピーコンストラクタによりコピーされた場合正常に動作しない、 ないし処理中や処理結果の関数オブジェクトインスタンスを使用したい場合等の場合には、 予め変数を宣言し、そのポインタを指定する事により、インスタンスのコピーを行わず、 直接指定ポインタのインスタンスを使用させる事が可能です。

 #include "roast/thread.hpp"
 class CHoge
 {
 public:
         int m_a;
         int m_result;
         CHoge(int a){ m_a = a; }
 
         int operator()(int b)
         {
                 m_result = m_a + b;
         }
 };
 
 void main( void )
 {
         CHoge hoge(10);
         roast::thread a(&hoge,20);
         a.join();
         printf("Result: %d", hoge.m_result);
 }

コンストラクタからの例外送出

startメソッドは復帰値型boolになっており、スレッド作成失敗時にはfalseを復帰する。 しかしコンストラクタは復帰値を持てないため、スレッド作成失敗時には thread_exception クラスによる例外を送出するようになっている。