std::async (c++11)

1. C++標準の非同期処理 (std::thread, std::jthread, std::async)

C++標準には、非同期処理を行う方法に std::thread, std::jthread, std::async の3つがあります。

最初にこの3つについて概要を記載します。

🦊 参考（選び方の目安）

🧵 std::thread

🌿 std::jthread

⚡ std::async

以下、本ページでは std::async について記載します。

2. std::async のシンプルな使用例

[概要]

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

[評価環境]

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

#include <iostream>     // std::cout, std::endl
#include <vector>       // std::vector
#include <future>       // std::async, std::future
#include <chrono>       // chrono::seconds, chrono::milliseconds, chrono::microseconds
#include <thread>       // std::this_thread::sleep_for
#include <string>       // std::string
#include <functional>   // std::cref

/// @brief data の合計値を計算する
/// @param data : 合計値を計算するデータ
/// @return data の合計値
int calcurateSum(const std::vector<int>& data)
{
    int sum = 0;
    for (auto i : data) {
        // 重たい処理
        std::this_thread::sleep_for(std::chrono::milliseconds(2000));
        sum += i;
        std::cout << "sum = " << sum << std::endl;
    }

    //throw std::runtime_error("test");

    return sum;
}

/// @brief std::async (非同期処理) のサンプルコード
/// @return EXIT_SUCCESS
int main()
{
    std::vector<int> data = { 1, 2, 3, 4, 5 };

    // calcurateSum() 関数を実行する
    // 引数が const なので cref() を使用。変更可能な場合は ref() で参照渡し。 
//  future<int> f = std::async( launch::async, calcurateSum, cref(data) );                     // 非同期実行
//  future<int> f = std::async( launch::deferred, calcurateSum, cref(data) );                  // 同期実行
//  future<int> f = std::async( launch::async | launch::deferred, calcurateSum, cref(data) );  // 非同期/同期 どちらでもOK
//  future<int> f = std::async( calcurateSum, cref(data));                                     // 非同期/同期 どちらでもOK
    auto f = std::async( std::launch::async, calcurateSum, cref(data));                        // auto による推奨の使用方法。非同期実行。
    try {
        if (f.wait_for(std::chrono::seconds(0)) == std::future_status::deferred) {
            // launch::deferred is selected.
            std::cout << "data の合計値は " << f.get() << "です" << std::endl;
        }
        else {
            // launch::async is selected.
            while (1) {
                if ( f.wait_for(std::chrono::milliseconds(500)) == std::future_status::ready ) {
                    std::cout << "data の合計値は " << f.get() << "です" << std::endl;
                    break;
                }
                else {
                    std::cout << "wait..." << std::endl;
                }
            }
        }
    }
    catch (const std::exception& ex) {
        std::cout << "exception catched: " << ex.what() << std::endl;
    }
    catch (...) {
        std::cout << "exception catched." << std::endl;
    }

    return EXIT_SUCCESS;
}

ビルド方法：

$ g++ -std=c++20 -Wall -Wextra -Wpedantic -pthread -O2 async_01.cpp -o async_01.out

Makefile 例：

CXX := g++
CXXFLAGS := -std=c++23 -O2 -Wall -Wextra -Wpedantic -pthread

ifeq ($(DEBUG),1)
    CXXFLAGS += -g
endif

SRC := async_01.cpp
OUT := $(SRC:.cpp=.out)

.PHONY: all run clean help

all: $(OUT)

$(OUT): $(SRC)
	@printf "Compiling %s -> %s\n" "$<" "$@"
	$(CXX) $(CXXFLAGS) "$<" -o "$@"

run: $(OUT)
	@./$(OUT)

clean:
	@rm -f $(OUT)

help:
	@printf "Usage:\n"
	@printf "  make         Build async_01.cpp -> async_01.out\n"
	@printf "  make run     Build then run the binary\n"
	@printf "  make clean   Remove generated binary\n"
	@printf "  make help    Show this help message\n"

実行結果：

$ ./async_01.out 
wait...
wait...
wait...
sum = 1
wait...
wait...
wait...
wait...
sum = 3
wait...
wait...
wait...
wait...
sum = 6
wait...
wait...
wait...
wait...
sum = 10
wait...
wait...
wait...
wait...
sum = 15
data の合計値は 15です
$ 

補足説明：

• std::async の第一引数に launch::async を指定した場合、内部的にスレッドを生成して非同期の動作を行います。
  std::async の第一引数に launch::deferred を指定した場合は同期実行します。通常の関数動作とお考え下さい。
  std::async の第一引数を 無指定、または "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

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

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

[評価環境]

[プログラムソース] "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

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

[概要]

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

[環境]

[プログラムソース] "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;
}
  

[実行結果]

結論：

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

ライセンス

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

参考

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

記載

Programming Items トップページ

プライバシーポリシー