std::async (c++11)

1. シンプルな例

[概要]

まずはシンプルなサンプルを作ってみます。
少し処理の重たい関数 worker() を準備して、これを std::async で実行します。

[評価環境]

#include <stdio.h>
#include <tchar.h>
#include <iostream>
#include <vector>    // std::vector
#include <future>    // std::async, std::future
#include <windows.h> // OutputDebugString

using namespace std;

int worker(const vector<int>& data)
{
    int sum = 0;

    for (int i : data) {
        // 重たい処理
        this_thread::sleep_for(chrono::milliseconds(2000));
        sum += i;
        cout << "sum = " << sum << endl;
    }

    //throw std::wstring(L"test");

    return sum;
}


int main()
{
    vector<int> data = { 1, 2, 3, 4, 5 };

    // worker() 関数を実行する
    // 引数が const なので cref() を使用。変更可能な場合は ref() で参照渡し。 
//  future<int> f = std::async( launch::async, worker, cref(data) );                     // 非同期実行
//  future<int> f = std::async( launch::deferred, worker, cref(data) );                  // 同期実行
//  future<int> f = std::async( launch::async | launch::deferred, worker, cref(data) );  // 非同期/同期 どちらでもOK
//  future<int> f = std::async( worker, cref(data));                                     // 非同期/同期 どちらでもOK
    auto f = std::async( launch::async, worker, cref(data));                             // auto による推奨の使用方法。非同期実行。

    try {
        if (f.wait_for(chrono::seconds(0)) == future_status::deferred) {
            // launch::deferred is selected.
            cout << f.get() << endl;
        }
        else {
            // launch::async is selected.

            while (1) {
                if (f.wait_for(chrono::milliseconds(500)) == std::future_status::ready) {
                    cout << f.get() << endl;
                    break;
                }
                else {
                    cout << "wait..." << endl;
                }
            }
        }
    }
    catch (std::wstring errorMessage) {
        OutputDebugString(errorMessage.c_str());
    }
    catch (...) {
        // worker() 関数内で例外創出された場合の処理
        OutputDebugString(_T("exception catched."));
    }

    return EXIT_SUCCESS;
}

［補足説明］

• std::async の第一引数に launch::async を指定した場合、内部的にはスレッドを生成しての非同期の動作を行います。
  launch::deferred を指定した場合は同期実行します。通常の関数動作とお考え下さい。
  無指定、または "launch::async | launch::deferred" を指定した場合、どちらで実行しても良い、という意図になります。
  std::async を使用する時点で非同期実行を意図しているはずなので、通常は launch::async を明示的に指定した方が良いと考えます。
• 非同期実行の場合、対象のタスクが終了しているかを確認してから結果を取得します。
  上記例では 上記例では 「f.wait_for(chrono::milliseconds(500)) == std::future_status::ready」 により最大500msの時間だけ処理完了を待ち、 f.get() を実行することで処理結果を取得します。
• 同期実行であることが明確な場合は、状態を確認する必要ありません。
  f.get() を実行するまで処理自体が行われません。
• どちらで実行しているかがわからない場合、両方を考慮した実装を行う必要があります。

サンプルプログラム

サンプルプログラム ダウンロード

参考URL

• http://ja.cppreference.com/w/cpp/thread/async

2. 一時停止状態のスレッドを作る

一時停止状態のシステムスレッドを作成してみます。
すなわち、スレッドで何かを処理する時が来たらすぐに開始できるようにあらかじめスレッドを作成しておき、作成のスレッドのオーバーヘッドによる遅延を回避する例です。または、実行開始前にスレッドに何かしらのせえっていを行う必要があるため一時停止状態のスレッドを作成する場合もあるでしょう。
スレッドを一度だけ一時停止状態にしたい場合、void future を用いるのが妥当な選択です。この技法の要点を以下に示します。

[評価環境]

[プログラムソース： "test_async_02.cpp"]

#include <iostream>
#include <future>		// std::async

using namespace std;

int react( int count )
{
    cout << "Start react()." << endl;
    for (int i = 0; i < count; ++i) {
        this_thread::sleep_for(chrono::milliseconds(1000));
    }
    cout << "Finish react()." << endl;
    return 1;
}

int main()
{
    promise<void> p;
    int wait_count = 5;

    future<int> f = async(launch::async, [=,&p]
    {
      p.get_future().wait();                                // p.set_value() の実行まで待機
      return react(wait_count);                             // react() を実行
    });

    this_thread::sleep_for(chrono::seconds(1));             // 何か・・・をしてから、
    p.set_value();                                          // スレッドを起動します。

    cout << "f.get() = " << f.get() << endl;                // react() の完了を待って戻り値を取得
    cout << "Confirmed termination of react()." << endl;
}

[実行結果]

参考

• 「Effective Modern C++」 項目39：イベントが１度切ならば void な future を検討する
• http://ja.cppreference.com/w/cpp/thread/async

3. async で作成したスレッドの終了を待たずに main を終了したらどうなる？

[概要]

std::thread だと join または detatch が必須です。
std::async の場合は detatch に相当する機能がないけれど、終了確認せずに worker スレッドを放置したらどうなるのでしょうか。
確認してみました。

どうやら特に考慮は不要みたいです。
main タスクが終了しても async タスクの動作は継続しました。
逆に main タスクが終了したにもかかわらず async タスク側が残ってしまう場合があるので、必要に応じて main タスク終了時に別スレッドを適切に終了するという処理が必要そうです。

[環境]

"test_async_03.cpp"]

#include <iostream>
#include <vector>   // vector
#include <chrono>   // chrono
#include <thread>   // this_thread
#include <future>   // async, future, future_status

#include <windows.h>    // OuputDebugString
#include <tchar.h>      // _T

using namespace std;


int worker(const vector<int>& data)
{
    int sum = 0;

    for (int i : data) {
        // 重たい処理
        this_thread::sleep_for(chrono::milliseconds(2000));
        sum += i;
        cout << "sum = " << sum << endl;
    }

    //throw std::wstring(L"test");

    return sum;
}


int main()
{
    vector<int> data = { 1, 2, 3, 4, 5 };

    // worker() 関数を実行する
    future<int> f = std::async( launch::async, worker, ref(data) );                     // 非同期実行

    // このまま worker スレッドの終了を待たずに終了... どうなる？
    // std::thread なら join または detatch が必要だけど...
    cout << "[INF] Finish main task." << endl;

    return EXIT_SUCCESS;
}
  

[実行結果]

ライセンス

本ページの情報は、特記無い限り下記 MIT ライセンスで提供されます。

参考

• http://ja.cppreference.com/w/cpp/thread/async

記載

Programming Items トップページ

プライバシーポリシー