C++ async 使い方：非同期処理の基本からC++26時代の最新プラクティスまで解説

2026年5月13日

非同期処理

C++における並列処理の歴史は長く、その中でもstd::asyncは非常に重要な役割を担ってきました。

現代のソフトウェア開発において、マルチコアCPUの性能を最大限に引き出すための非同期処理は欠かせない技術の一つです。

C++11で導入されたstd::asyncは、低レイヤーなスレッド操作を抽象化し、戻り値を持つ非同期タスクを簡潔に記述することを可能にしました。

2026年現在、C++26の策定や普及が進む中で、非同期処理の選択肢はstd::executionやコルーチンなど多岐にわたっています。

しかし、依然としてシンプルで使い勝手の良いstd::asyncの基本を押さえることは、すべてのC++エンジニアにとって必須の知識と言えます。

この記事では、std::asyncの基本的な使い方から、最新のC++規格を意識した実践的なプラクティスまでを詳しく解説します。

目次 [ close ]

std::asyncの基本的な役割と仕組み

std::asyncは、関数や関数オブジェクトを非同期に実行するための高レベルなインターフェースです。

従来のスレッド生成に使用されるstd::threadと異なり、実行した関数の戻り値を直接取得できる点が大きな特徴です。

内部的にはスレッドの管理を標準ライブラリ側が行うため、開発者はハードウェアのリソースを過度に意識することなく並列化を実装できます。

std::futureとの連携

std::asyncを呼び出すと、その戻り値としてstd::future<T>型のオブジェクトが返されます。

このstd::futureは「将来得られる結果」を保持するためのプロキシオブジェクトとして機能します。

非同期タスクが完了するまでメインスレッドの処理を継続し、必要なタイミングで.get()メソッドを呼び出すことで結果を回収します。

もし.get()を呼び出した時点でタスクが完了していない場合、呼び出し元のスレッドはタスク完了まで待機（ブロック）されます。

基本的な構文と実装例

まずは、最もシンプルなstd::asyncの使用例を見てみましょう。

C++

// 基本的なstd::asyncの使用例
#include <iostream>
#include <future>
#include <chrono>
#include <thread>

// 重い処理をシミュレートする関数
int heavy_computation(int x, int y) {
    std::this_thread::sleep_for(std::chrono::seconds(2)); // 2秒待機
    return x + y;
}

int main() {
    // heavy_computationを非同期で実行
    std::future<int> result_future = std::async(heavy_computation, 10, 20);

    std::cout << "計算を開始しました。メインスレッドで他の処理を継続します..." << std::endl;

    // 非同期処理の完了を待って結果を取得
    int final_result = result_future.get();

    std::cout << "計算結果: " << final_result << std::endl;

    return 0;
}

実行結果

計算を開始しました。メインスレッドで他の処理を継続します...
（約2秒後）
計算結果: 30

実行ポリシーによる挙動の制御

std::asyncには、実行タイミングを制御するための「起動ポリシー（launch policy）」を指定することができます。

ポリシーを省略した場合、システムが最適な方法を自動的に選択しますが、意図しない挙動を防ぐために明示的な指定が推奨されるケースが多いです。

std::launch::async（強制的な非同期実行）

std::launch::asyncを指定すると、標準ライブラリは新しいスレッドを生成してタスクを直ちに開始することを試みます。

これにより、メインスレッドとは完全に独立した並列実行が保証されます。

ただし、スレッドの生成コストがかかるため、極端に短いタスクを大量に生成する場合はパフォーマンスに悪影響を与える可能性があります。

std::launch::deferred（遅延実行）

std::launch::deferredを指定した場合、新しいスレッドは生成されません。

タスクはstd::future::get()またはstd::future::wait()が呼び出された瞬間に、呼び出し元と同じスレッドで実行されます。

これは「必要な時まで計算を後回しにする」レイジー・エバリュエーション（遅延評価）を実現するためのものです。

ポリシーごとの挙動比較表

ポリシー	実行タイミング	実行スレッド	主な用途
std::launch::async	即時（可能な限り）	別スレッド	バックグラウンドでの並列計算
std::launch::deferred	get() / wait() 呼び出し時	呼び出し元と同じスレッド	リソース節約・遅延評価
未指定（デフォルト）	実装依存（状況により変化）	状況により変化	標準ライブラリへの一任

std::asyncの実践的な活用シーン

std::asyncは、単一の重いタスクを処理するだけでなく、複数の独立した処理を並行して進める際に真価を発揮します。

例えば、Web APIからのデータ取得とローカルデータベースのクエリを同時に実行し、最後にそれらをマージするようなケースです。

複数タスクの並列化例

C++

// 複数タスクを並列に実行する例
#include <iostream>
#include <future>
#include <vector>
#include <numeric>

int fetch_data_from_server() {
    std::this_thread::sleep_for(std::chrono::milliseconds(1500));
    return 100;
}

int read_data_from_db() {
    std::this_thread::sleep_for(std::chrono::milliseconds(1000));
    return 200;
}

int main() {
    // 2つのタスクを並行して開始
    auto future_server = std::async(std::launch::async, fetch_data_from_server);
    auto future_db = std::async(std::launch::async, read_data_from_db);

    // 2つの結果が揃うまで待ち合わせ
    int total = future_server.get() + future_db.get();

    std::cout << "合計スコア: " << total << std::endl;
    return 0;
}

実行結果

合計スコア: 300

この例では、個別に実行すると合計2.5秒かかる処理が、並列実行により約1.5秒で完了します。

例外処理と安全性

非同期処理において非常に重要なのが、タスク内で発生した例外の扱いです。

std::asyncで実行された関数の中で例外が投げられた場合、その例外は一旦キャッチされ、対応するstd::futureオブジェクトの中に保存されます。

その後、get()メソッドを呼び出したタイミングで例外が再送出される仕組みになっています。

例外ハンドリングのコード例

C++

// 非同期タスク内の例外をキャッチする
#include <iostream>
#include <future>
#include <stdexcept>

void risky_task() {
    throw std::runtime_error("タスク内でエラーが発生しました！");
}

int main() {
    auto f = std::async(std::launch::async, risky_task);

    try {
        f.get(); // ここで例外が再送出される
    } catch (const std::exception& e) {
        std::cerr << "例外を捕捉: " << e.what() << std::endl;
    }

    return 0;
}

パフォーマンス上の注意点と「デストラクタの罠」

std::asyncを使用する際に必ず知っておかなければならない、C++特有の挙動があります。

それは、std::asyncの戻り値であるstd::futureの一時オブジェクトが破棄される際の挙動です。

std::async(std::launch::async, ...)によって生成されたstd::futureのデストラクタは、タスクが完了するまで呼び出し元のスレッドをブロックします。

つまり、戻り値を変数で受け取らずに使い捨てにすると、その行で処理が完了するまで待機してしまい、非同期処理の意味がなくなってしまいます。

非同期にならないアンチパターンの例

C++

// 悪い例：非同期実行を期待しているが、逐次実行になる
std::async(std::launch::async, task1); // ここでtask1が終わるまでブロック
std::async(std::launch::async, task2); // ここでtask2が終わるまでブロック

必ず戻り値を変数に保持し、スコープを適切に管理することが重要です。

C++26時代における非同期処理の進化

2026年現在、C++の非同期処理モデルは大きな転換期を迎えています。

これまで解説したstd::asyncは、非常に使いやすい反面、スレッド生成のオーバーヘッドや、複数のタスクを複雑に組み合わせる機能に乏しいという課題がありました。

std::execution (P2300 Senders/Receivers)

C++26において本格的な導入が進んだstd::executionフレームワークは、より高度で効率的な非同期プログラミングを提供します。

これは「Sender/Receiver」モデルと呼ばれ、スレッドプールの活用や、タスクの連鎖（パイプライン）を低コストで実現します。

小規模なスクリプトや単純な並列計算にはstd::asyncが適していますが、大規模なアプリケーションの基盤にはstd::executionが採用される傾向にあります。

コルーチンとの使い分け

C++20で導入されたコルーチン（co_await）は、非同期処理の記述を「同期処理のように」書くための強力な構文です。

std::asyncが「スレッド単位の並列化」に主眼を置いているのに対し、コルーチンは「I/O待ちなどの待機時間を効率的に扱う」ことに長けています。

CPUバウンドな重い計算はstd::asyncやstd::executionでマルチコアを活用し、ネットワーク通信などの待機が多い処理はコルーチンで記述するというのが2026年現在のベストプラクティスです。

std::asyncを使いこなすためのTips

実際にプロダクションコードでstd::asyncを利用する場合、以下の点に配慮するとより堅牢なプログラムになります。

共有リソースへのアクセス: 非同期タスク内で共有変数にアクセスする場合は、必ずstd::mutex等で同期を取るか、アトミック変数を使用してください。
タスクの粒度: あまりにも細かすぎる処理をstd::asyncに投げると、スレッド生成のコストが計算時間の利益を上回ってしまいます。
ハードウェアの並列度: std::thread::hardware_concurrency()を使用して、コア数に応じた適切なタスク分割を検討してください。
キャンセル機構: std::async自体にはタスクを途中で停止させる機能がありません。std::stop_token（C++20以降）などを用いて、自前でキャンセル判定を組み込むのが一般的です。

キャンセル可能なタスクの実装例

C++

// キャンセル可能な非同期処理
#include <iostream>
#include <future>
#include <stop_token>

void cancelable_task(std::stop_token stoken) {
    for (int i = 0; i < 10; ++i) {
        if (stoken.stop_requested()) {
            std::cout << "タスクがキャンセルされました。" << std::endl;
            return;
        }
        std::this_thread::sleep_for(std::chrono::milliseconds(500));
        std::cout << "処理中... " << i << std::endl;
    }
}

int main() {
    std::stop_source ssource;
    auto future = std::async(std::launch::async, cancelable_task, ssource.get_token());

    std::this_thread::sleep_for(std::chrono::seconds(2));
    ssource.request_stop(); // キャンセルを要求

    future.wait();
    return 0;
}