名前空間
変種
操作

std::promise

提供: cppreference.com
< cpp‎ | thread
 
 
スレッドサポートライブラリ
スレッド
(C++11)
this_thread 名前空間
(C++11)
(C++11)
(C++11)
相互排他
(C++11)
汎用ロック管理
(C++11)
(C++11)
(C++11)
(C++11)(C++11)(C++11)
(C++11)
(C++11)
条件変数
(C++11)
フューチャー
promise
(C++11)
(C++11)
(C++11)
(C++11)
 
 
ヘッダ <future> で定義
template< class R > class promise;
(1) (C++11およびそれ以降)
template< class R > class promise<R&>;
(2) (C++11およびそれ以降)
template<>          class promise<void>;
(3) (C++11およびそれ以降)
1) 基本テンプレート
2) スレッド間でオブジェクトをやり取りするために使用される非 void 特殊化
3) ステートレスなイベントをやり取りするための void 特殊化

クラステンプレート std::promise は、 std::promise オブジェクトによって作成された std::future オブジェクトを通して後に非同期に取得される、値または例外を格納する機能を提供します。

各々のプロミスは「共有状態」に紐付いています。 共有状態は何らかの状態情報と、「まだ評価されていない」「値 (void も有り得る) に評価された」「例外に評価された」のいずれかの「結果」を持ちます。 プロミスは共有状態を使用して以下の3つのことをします。

  • 準備完了状態にする: 共有状態に結果または例外を格納します。 状態を準備完了に設定し、共有状態に紐付いているフューチャーで待機しているあらゆるスレッドのブロックを解除します。
  • 解放する: 共有状態への参照を放棄します。 これが最後の参照であった場合、その共有状態は破棄されます。 これが std::async によって作成された準備完了していない共有状態でない限り、この操作はブロックしません。
  • 放棄する: エラーコード std::future_errc::broken_promise を持った std::future_error 型の例外を格納します。 これにより共有状態は準備完了になり、そして解放されます。

プロミスはプロミスとフューチャーの通信チャネルの「プッシュ」側の端点です。 共有状態に値を格納する操作は、その共有状態で待機する任意の関数 (std::future::get など) からの成功による戻りに対して同期します (std::memory_order を参照してください)。

目次

[編集] メンバ関数

プロミスオブジェクトを構築します
(パブリックメンバ関数) [edit]
プロミスオブジェクトを破棄します
(パブリックメンバ関数) [edit]
共有状態を代入します
(パブリックメンバ関数) [edit]
2つのプロミスオブジェクトを入れ替えます
(パブリックメンバ関数) [edit]
結果の取得
約束された結果に紐付けられた future を返します
(パブリックメンバ関数) [edit]
結果の設定
特定の値に結果を設定します
(パブリックメンバ関数) [edit]
スレッド終了時にのみ通知が配送されるように特定の値に結果を設定します
(パブリックメンバ関数) [edit]
例外を表す結果を設定します
(パブリックメンバ関数) [edit]
スレッド終了時にのみ通知が配送されるように例外を表す結果を設定します
(パブリックメンバ関数) [edit]

[編集] 非メンバ関数

std::swap アルゴリズムの特殊化
(関数テンプレート) [edit]

[編集] ヘルパークラス

std::uses_allocator 型特性の特殊化
(クラステンプレートの特殊化) [edit]

[編集]

この例はスレッド間の信号として promise<int> をどのように使用できるかを示します。

#include <vector>
#include <thread>
#include <future>
#include <numeric>
#include <iostream>
#include <chrono>
 
void accumulate(std::vector<int>::iterator first,
                std::vector<int>::iterator last,
                std::promise<int> accumulate_promise)
{
    int sum = std::accumulate(first, last, 0);
    accumulate_promise.set_value(sum);  // Notify future
}
 
void do_work(std::promise<void> barrier)
{
    std::this_thread::sleep_for(std::chrono::seconds(1));
    barrier.set_value();
}
 
int main()
{
    // Demonstrate using promise<int> to transmit a result between threads.
    std::vector<int> numbers = { 1, 2, 3, 4, 5, 6 };
    std::promise<int> accumulate_promise;
    std::future<int> accumulate_future = accumulate_promise.get_future();
    std::thread work_thread(accumulate, numbers.begin(), numbers.end(),
                            std::move(accumulate_promise));
    accumulate_future.wait();  // wait for result
    std::cout << "result=" << accumulate_future.get() << '\n';
    work_thread.join();  // wait for thread completion
 
    // Demonstrate using promise<void> to signal state between threads.
    std::promise<void> barrier;
    std::future<void> barrier_future = barrier.get_future();
    std::thread new_work_thread(do_work, std::move(barrier));
    barrier_future.wait();
    new_work_thread.join();
}

出力:

result=21