#include "pch.h"
の#include <iostreamの>
の#include <文字列>
の#include <ベクトル>
の#include <リスト>
//线程相关头文件
する#include <スレッド>
の#include <ミューテックス>
書式#include <未来>
名前空間を使用してSTD;
静的なint型のRES = 0; //は、共有変数の書き込みミューテックスの使用を示します。
ミューテックスmy_mutex; //ミューテックス
ミューテックスmy_mutex2;
パラメータなし//ボイド試験（）
{
オートID = this_thread :: GET_ID（）;
COUT << "= NOパラメータID" << ENDL << ID;
/ *ミューチュアル保護されたデータ撥ロックの量及び形状* /アンロック
my_mutex.lockを（）;
//ロック（my_mutex、my_mutex2）;同時に全て相互排他ロックと同等
のRES = 1;
my_mutex.unlock（）; //対に右。
リターン;
}
ボイドTEST2（INT）
{
オートID = this_thread :: GET_ID（）;
COUT << "引数ID =" << ENDL << ID;
/ *
データ保護のミューテックスlock_guardフォーム。
パラメータadopt_lock（目標構造）アクションは、ミューテックスロックがあります。
* /
Lock_guard <ミューテックス> my_lock（my_mutex）; // lock_guard <ミューテックス> my_lock（my_mutex、adopt_lock）;.
2 = RES;
返します。
{
パブリック：
ボイド演算子（）（）//ないパラメータを持つ
{
オートID = this_thread :: GET_ID（）;
COUT << "=クラスのオブジェクトID" << ENDL << ID;
リターン;
}
なcall_onceの//
静的ボイドひとたび（）
{
リターン;
}
};
無効秒（）
{
リターン;
}
ボイドmy_async（）;
ボイドmy_packaged（）;
ボイドmy_promise_は（）;
int型のmain（）
{
int型TEMP、
スレッドmy_thread（テスト）;
//最初の機能を含む呼出可能オブジェクトパラメータ、クラス（定義される（）演算子のオーバーロード）、ラムダ式、対応するパラメータの関数として後続のパラメータ。
my_thread2スレッド（TEST2、TEMP）;
メインスレッドに戻って、子スレッドが終了して参加してのために//待ちます
（my_thread.joinableは（））//結合可能子スレッドが参加するかどうかを判定した場合/デタッチ
{
my_thread.joinは（）;
}
一旦スレッドが参加することができ//
my_thread2.joinを（）;
/ *可能な限り（子スレッドを待たずにデタッチ未使用）
my_thread.detach（）;
my_thread2.detach（）;
* /
A A;
スレッドmy_thread3（A）;
my_thread3.join（）。
//なcall_once（）関数は一度だけ、より効率的に行われることを保証するためにミューテックス能力を含みます。使用して（これも構造）once_flagマーカーの組み合わせが必要です
。g_flagをonce_flag
; once_flag p_flag
なcall_onceの（g_flag、::一度）;
なcall_once（p_flag、SECOND）の;
//非同期将来に関連します。
my_async（）;
my_packaged（）;
my_promise_（）;
COUT << <<てendl "Iラブチャイナ！";
の戻り0;
}
//より柔軟なunique_lockのクラステンプレート。あなたは2番目のパラメータはadopt_lock（lock_guardでは、最初にロックすることを提供）しているロックを解除する必要はありませんlock_guardを置き換えることができます
// try_to_lock（前提がロックしないで、スレッドをブロックしません。）
// defer_lock（前提がロックしないで、ロック解除ミューテックスを初期化）メンバ関数を直接呼び出すことができます。
//メンバ関数ロック（）
//ロック解除（）
// try_lock（）my_unique。try_lock（）==真の表現がロックを取得するには、ロックが乾燥するために他のものを取得できませんでした。
//放出（）オブジェクトへのポインタを返し、ミューテックスミューテックスの所有権を解放* PTR = my_unique.release（）; ptr->ロック解除（）;
// unique_lockの<ミューテックス> my_unique（my_mutex）より少ないロックコード、細かい粒度。
// unique_lockの<ミューテックス> my_unique2（移動:: my_uniqueを）//所有権の移転を
/ * ------------------------------------------------ ------------------------------
condition_variable待機（）notify_one notify_all
condition_variable my_cond発生条件変数オブジェクトは、ミューテックスで作業する必要があります
すべてnotify_allを覚ますnotify_oneウェイクを待って待って待って
-------------------------------------------------- ---------------------------- * /
condition_variable my_cond;
ミューテックスmy_mutex3;
BOOL JUGE（）
{
（真）であれば
{
trueを返します。
}
falseを返します。
}
outmsgボイド（）
{
コマンド= 0 int型、
一方が（trueに）
{
unique_lockのは<ミューテックス> my_mu（my_mutex3）である。
my_cond.wait（my_mu、JUGE）;
// 2番目のパラメータは、ミューテックスのロックを解除し、次に偽を返し、そして目詰まり、別のスレッドがこれまでに（）メンバ関数NOTIFY_ONCE呼び出すまで。
// 2番目のパラメータのデフォルト値はfalseです
//食事操作。。。
//欠落は、後続の動作条件（例えば、共有、メッセージ・キューなどのデータを書き込むために書き込み動作を待つ必要なしにメッセージを読み取ることができません。）を防止することができます
//mes.pop_back（）は、最初のメッセージを読み出します。
ブレーク;
}
}
inMsgボイド（）
{
（;; I <100000私は++ I = 0をint型）のための
{
unique_lockのは、<ミューテックス> my_mu（my_mutex3）である;
//食事動作
my_cond.notify_one（）; //は、（ウェイトを目覚めしようとする）は、mutexロック彼が解放された後。
// notify_all（））（すべての待機を目覚めます;
}
}
/ * ----------------------------------------------- -------------------------------
非同期非同期タスクを開始する（自動的にスレッドを作成）し、値を返し、将来のクラステンプレートに戻ります。
将来は、非同期操作へのアクセスがメカニズムの結果を返します。
packaged_taskのラッパー関数
約束クラステンプレート、スレッドの割り当てでは、抽出約束<整数>別のスレッドでmy_promise。
-------------------------------------------------- ---------------------------- * /
int型mythread（）
{
オートID = this_thread :: GET_ID（）。
COUT << "非同期的ID =" << ID << ENDL。
//使线程睡觉5秒
クロノ::ミリ秒の硬膜（5000）;
this_thread :: sleep_for（硬膜）。
COUT << "非同期的ID =" << ID << ENDL。
5を返します。
}
my_asyncのボイド（）
{
//フューチャー<整数>結果=非同期（MyThread）;
//デフォルトパラメータの非同期を待たずに。
将来の<整数>結果=非同期（打ち上げ::延期、mythread）; // それは、クラスのメンバ関数<整数>結果=非同期（＆である場合には、将来を呼び出す A :: mythread、＆AOBJ、 メンバ関数のパラメータ）。
// asnycは追加パラメータの列挙型のstd ::打ち上げを受け入れることができます
//この2つの機能は、スレッドが作成されることはありませんない場合は、実行前に（）のスレッドをGET（）を呼び出し、待ってまで呼び出す遅らせるため延期。
<<裁判所未満"続行....." <<てendl;
coutの<< "続行....." <<てendl;
coutの<< "続行....." <<てendl;
coutの<<「続行.....「<<てendl;
//（getを使用）は、スレッドの結果を返します。付きまとっ戻り値を取得しないでください。
COUTは<< "非同期結果が返さ=" << result.get（）<< ENDL;
リターン;
}
int型mythread1（INT MYPT）
{
戻りMYPT;
}
ボイドmy_packaged（）
{
packaged_task <整数（INT）> MYPT（mythread1）。
/ *ラムダ式
packaged_task <整数（INT）> MYPT（[]（INT MyPar）
{
}
）; / *
スレッドmy_pt（REF（MYPT）、1）。
my_pt.join（）;
将来の<整数> RES = mypt.get_future（）;
裁判所未満<< "パッケージ化返回结果：" << res.get（）<<てendl;
返します。
}
my_promiseボイド（約束<整数> TEMP＆、int型CUR）
{
CUR ++;
CUR = 10 *;
int型の結果= CUR; //結果の保存
temp.set_value（結果を）; //結果は約束の中に置かれます
}
空my_promise_（）
{
約束<整数> myprom。
スレッドT（my_promise、REF（myprom）、10）。
t.join（）;
将来の<整数> FU = myprom.get_future（）;
INT結果= fu.get（）。
裁判所未満<< "約束结果=" <<結果<<てendl;
返します。
}