C ++並列プログラミング "A"

1.最も簡単なマルチスレッドのC ++プログラム

書式#include <iostreamの> 
の#include <スレッド> 無効do_something（）
{ 
    のstd :: coutの << " FUNC do_something ... " << はstd ::てendl; 
} int型のmain（int型 ARGC、チャー * ARGV []）
{ 
    のstd ::スレッドmy_thread（do_something）。
    std :: coutの << " メインスレッド" << はstd ::てendl; 
    my_thread.join（）; リターン0 ; 
}

C ++標準のstd ::スレッド2.呼の任意のタイプ（呼び出し可能）で動作することができるが、それゆえ、我々は、に直接伝達関数呼び出し演算子ではstd ::スレッドコンストラクタクラスのインスタンスを与え、代わりにすることができ機能。

#include <iostreamの> 
する#include <スレッド> ボイドdo_something（）
{ 
    のstd :: COUT << " FUNC do_something " << はstd :: ENDL。
} クラスbackground_task 
{ パブリック：
     ボイド演算子（）（）のconst 
    { 
        do_something（）; 
    } 
}。INTメイン（int型 ARGC、チャー *のARGV []）
{ 
    background_taskのBT。
    std ::スレッドmy_thread（BT）。/ *传入一个类实例* / 
    STD :: coutの << "




 

メインスレッド「 << はstd :: ENDL; 
    my_thread.join（）; 

    戻り 0 ; 
}

糸の端3.待ち、C ++の方法（参加、離脱）スレッドの二種類の終わりがあります。デタッチ（）メソッドが懸念されるため、スレッドインスタンスはメインスレッドが破壊されても、スレッドがまだ自分の終了まで、背景を実行することができます。

join（）メソッドについては、メインスレッドは、実行の子スレッドを待ち、およびサブスレッドの戻り値を取得します。問題は、我々は例外が発生した場合、どのようにすることができますまだ正しい結末を子スレッドを確保するために、子スレッドの終了を待っているか、です。方法は以下の通り：

書式#include <iostreamの> 
の#include <スレッド> 無効do_something（）
{ 
    のstd :: coutの << " FUNC do_something ... " << はstd ::てendl; 
} クラスbackground_task 
{ パブリック：
     ボイド演算子（）（）
    { 
        do_something（）; 
    } 
    background_task（int型のval）
    { 
        のstd :: COUT << " background_taskコンストラクタINIT " << はstd :: ENDL。
    } 
}。




 

argc、char型 * ARGV []）
{ 
    int型 = init_val 0 ; 
    background_task BT（init_val）; 

    STD ::スレッドmy_thread（BT）; 

    試み
    { 
        STD :: COUT << " ERRがここに壁紙を発生し、" <<てendl STD ::; / * 誤り位置* / 
    } 
    キャッチ（...）
    { 
        my_thread.join（）;                          / * ために糸の正常終了を確保することができ、例外的な状況で* / 
        スロー; 
    } 
    my_thread.join（）;                              / * プログラムの終了位置* / 
    復帰 0 ; 
}

4.プロセスの終了のtry / catchモード、コードリーダが減少し、スコープを混同しやすい、より鮮やかな方法のためのしたがって、必要性だけでなく。これを行う方法の1つは、買収は、初期化（RALL）イディオムであるリソースを使用することです。

次のように：

#include <iostreamの> 
する#include <スレッド> クラスthread_guard 
{ 
    STD ::スレッド＆T;            / * これにコピー着信スレッドのエイリアスを定義* / 公共：
     明示 thread_guard（STD ::スレッド＆T_）：T（ T_）{}
    〜thread_guard（）
    { / * 処理動作の終了とクラスリソース解放結合限り、クラスがリリースされているように、スレッドは終了する* / IF （t.joinable（））
        { 
            t.joinを（）; 
        } 
    } 
    thread_guard（thread_guardのCONST＆）= 削除; 
    thread_guard＆演算子




        =（thread_guard CONST =＆）削除; 
}; 

ボイドdo_something（）
{ 
    STD :: COUT << " FUNCのdo_something " << STD :: ENDL; 
} 

構造体FUNC 
{ 
    INT＆I、
    FUNC（INT＆I_）：I（ I_）{}
     ボイド 演算子（）（）
    { 
        do_something（）; 
    } 
}; 

/ * メソッド簡単、異常な条件下で正常終了スレッドとすることができるようにすることができる* / 
int型のmain（int型 ARGC、CHAR * のargv [ ]）
{ 
    のInt = init_val 0 ; 
    FUNC my_func（init_val）; 
    STD ::スレッドmy_thread（my_func）; 
    G（my_thread）thread_guard; 
    戻り 0 ;                           / * メインスレッドの終了後は、ローカル変数はGが破壊される破壊され、待機サブ糸端* / 
}

おすすめ