【C++】std::thread::joinの基本から応用まで5つの完全解説！

はじめに

プログラミングでは、効率的なコードの実行が不可欠です。

特に、マルチスレッド処理は、アプリケーションのパフォーマンスを向上させる重要な要素です。

C++では、std::thread ライブラリを使用して、スレッドを効果的に管理し、そのパワーを最大限に活用することができます。

この記事では、C++のstd::thread::join機能に焦点を当て、初心者でも理解しやすいように、基本から応用、注意点に至るまで、詳細に解説します。

●C++とstd::thread::joinの基本

C++はパワフルなプログラミング言語で、特にシステムレベルのプログラミングや高度なアプリケーション開発に広く使用されています。

C++11からは、言語の一部としてマルチスレッド処理がサポートされるようになりました。

この中で、std::thread ライブラリは、スレッドの作成と管理を容易にする機能を提供しています。ここで重要な役割を果たすのが、std::thread::join関数です。

この関数は、スレッドがそのタスクを完了するまで、呼び出し元のスレッドをブロックすることで、スレッド間の同期を可能にします。

○std::thread::joinとは？

std::thread::join関数は、新しく作成したスレッドが終了するのを待つために使用されます。

スレッドが終了すると、join関数は制御を呼び出し元のスレッドに戻します。

これにより、複数のスレッドが同時に実行されるアプリケーションにおいて、メインスレッドがサブスレッドの完了を正確に待つことができます。

joinを使用しない場合、サブスレッドが完了する前にメインスレッドが終了し、未完了のスレッドが残るリスクがあります。

○スレッドの基本的な概念

スレッドとは、プログラム内で独立した実行の流れを持つ単位です。

各スレッドは、プログラムの一部を並行して実行することで、リソースの利用効率を高め、応答性の高いアプリケーションを実現します。

C++におけるスレッド処理は、std::thread ライブラリを通じて行われ、スレッドを生成し、管理し、同期するための多くのツールが提供されます。

重要なのは、各スレッドがメモリやリソースを共有するため、データの整合性とスレッド間の正確な同期が必要となる点です。

●std::thread::joinの使い方

C++のstd::thread::join関数の使用方法は、マルチスレッドプログラミングにおける基本的かつ重要なスキルです。

join関数は、特定のスレッドが終了するまで、そのスレッドを生成したスレッドの実行を停止することで、スレッド間の同期を実現します。

この機能により、複数のスレッドが同時に動作している状況で、各スレッドが他のスレッドの終了を確実に待てるようになります。

スレッドのjoinは、主に二つの主要な目的で使用されます。

一つは、スレッドが共有リソースへの変更を完了させることを保証するため、もう一つは、スレッドが完了するまでプログラム全体の終了を遅らせるためです。

この方法により、データの不整合や未定義の挙動を避けることができます。

○サンプルコード1：基本的なjoinの使用

ここでは、std::thread::joinの基本的な使用法を示す簡単な例を紹介します。

この例では、メインスレッドから別のスレッドを生成し、そのスレッドで特定のタスクを実行した後、joinを呼び出しています。

この処理により、サブスレッドの完了をメインスレッドが待つことができます。

#include <iostream>
#include <thread>

void task() {
    // スレッドで実行されるタスク
    std::cout << "スレッドタスク実行中\n";
}

int main() {
    std::thread t(task);  // スレッドの生成
    t.join();             // スレッドの終了を待つ
    std::cout << "メインスレッド\n";
    return 0;
}

このコードでは、task 関数が別のスレッドで実行され、main 関数内でそのスレッドの終了をjoinによって待ちます。

task 関数の処理が完了すると、main 関数内の次の行が実行されます。

このようにjoinを使用することで、スレッド間の正確な同期が保たれます。

○サンプルコード2：複数スレッドのjoin処理

次に、複数のスレッドを生成し、それぞれのスレッドが終了するのをjoinを使って待つ例を紹介します。

この例では、複数のスレッドが同時に異なるタスクを実行し、メインスレッドは全てのスレッドが終了するのを待っています。

#include <iostream>
#include <thread>
#include <vector>

void task(int num) {
    std::cout << "スレッド " << num << " 実行中\n";
}

int main() {
    std::vector<std::thread> threads;

    // 3つのスレッドを生成
    for(int i = 0; i < 3; ++i) {
        threads.push_back(std::thread(task, i));
    }

    // 各スレッドの終了を待つ
    for(auto &t : threads) {
        t.join();
    }

    std::cout << "全スレッド終了\n";
    return 0;
}

このコードでは、task 関数が異なる引数で3回呼び出され、それぞれ異なるスレッドで実行されます。

メインスレッドはthreadsベクターに保存された全スレッドの終了を待ちます。

このようにjoinを使うことで、複数のスレッドが安全に終了し、リソースの解放を適切に行うことができます。

●std::thread::joinの応用例

std::thread::joinの基本的な使い方を理解した上で、より高度な応用例を探求することが重要です。

応用例としては、例外処理の組み込み、joinのタイミングを制御する方法、効率的なスレッド管理などが挙げられます。

これらの技術は、より複雑で要求の高いマルチスレッド環境において、プログラムの安定性と効率を高めるのに役立ちます。

○サンプルコード3：例外処理とjoin

マルチスレッドプログラムでは、スレッド内で発生する例外を適切に処理することが不可欠です。

スレッド内で例外が発生した場合、その例外を捕捉し、適切に処理する必要があります。

下記のサンプルコードでは、スレッド内で発生した例外を捕捉し、メインスレッドで処理する方法を表しています。

#include <iostream>
#include <thread>
#include <exception>

void task() {
    throw std::runtime_error("スレッド内例外");
}

int main() {
    std::thread t;

    try {
        t = std::thread(task);
        t.join();
    } catch(const std::exception& e) {
        std::cout << "例外捕捉: " << e.what() << '\n';
    }

    return 0;
}

このコードでは、task 関数内で例外を発生させ、メインスレッドでその例外を捕捉しています。

これにより、スレッド内での予期しない挙動を安全に処理することができます。

○サンプルコード4：joinのタイミングを制御する方法

スレッドの終了を待つタイミングを制御することも、応用的な使い方の一つです。

例えば、複数のスレッドがある程度進行した後で同期を取りたい場合、joinのタイミングを適切に制御する必要があります。

下記のサンプルコードでは、スレッドの実行状況に応じてjoinを呼び出すタイミングを調整しています。

#include <iostream>
#include <thread>
#include <vector>
#include <chrono>

void task(int num) {
    std::this_thread::sleep_for(std::chrono::seconds(num));
    std::cout << "スレッド " << num << " 完了\n";
}

int main() {
    std::vector<std::thread> threads;

    for(int i = 0; i < 3; ++i) {
        threads.push_back(std::thread(task, i));
    }

    for(auto &t : threads) {
        t.join();
    }

    std::cout << "全スレッド終了\n";
    return 0;
}

このコードでは、各スレッドが異なる時間でタスクを完了させ、メインスレッドがすべてのスレッドが終了するのを待っています。

これにより、スレッド間のタイミングを柔軟に制御することが可能になります。

○サンプルコード5：効率的なスレッド管理とjoin

最後に、複数のスレッドを効率的に管理する方法を考えます。

これは、大規模なアプリケーションや複雑なタスクを扱う際に特に重要です。

下記のサンプルコードでは、スレッドプールを使用して、複数のスレッドを効率的に管理し、その終了をjoinで待つ方法を表しています。

#include <iostream>
#include <thread>
#include <vector>
#include <functional>
#include <queue>

class ThreadPool {
private:
    std::vector<std::thread> workers;
    std::queue<std::function<void()>> tasks;

public:
    ThreadPool(size_t threads) {
        for(size_t i = 0; i < threads; ++i) {
            workers.emplace_back([this] {
                while(true) {
                    std::function<void()> task;
                    if(!tasks.empty()) {
                        task = std::move(tasks.front());
                        tasks.pop();
                        task();
                    }
                }
            });
        }
    }

    ~ThreadPool() {
        for(std::thread &worker : workers) {
            worker.join();
        }
    }

    void enqueue(std::function<void()> task) {
        tasks.push(task);
    }
};

int main() {
    ThreadPool pool(4);

    pool.enqueue([] { std::cout << "タスク1\n"; });
    pool.enqueue([] { std::cout << "タスク2\n"; });
    // さらにタスクを追加

    return 0;
}

このコードでは、スレッドプールを使って複数のタスクを同時に処理し、スレッドの終了を効率的に管理しています。

このような方法を用いることで、リソースの利用効率を高めることができます。

●std::thread::joinの注意点と対処法

std::thread::joinを使用する際には、いくつかの重要な注意点があります。

これらの点を理解し、適切な対処法を講じることで、スレッドをより安全かつ効率的に管理することが可能になります。

特に重要なのは、デッドロックの回避とリソースの効率的な利用です。

○スレッドのデッドロック回避

デッドロックは、複数のスレッドが互いに終了を待ってしまい、全てのスレッドが停止してしまう状態を指します。

この状態に陥ると、プログラムが完全に停止してしまうため、非常に深刻な問題です。

デッドロックを避けるためには、スレッド間でのロック（排他制御）の使用を慎重に行う必要があります。

また、スレッドが互いに依存しないような設計を心がけることが重要です。

例えば、下記のような状況ではデッドロックが発生する可能性があります。

• スレッドAがリソースXをロックし、リソースYを待っている
• スレッドBがリソースYをロックし、リソースXを待っている

このような場合、スレッドAとBは永遠に待ち続けることになります。

この問題を回避するためには、スレッドがリソースをロックする順序を一貫させるなどの方法が有効です。

○リソースの効率的な利用

スレッドを使用する際は、リソースの利用を最適化することが重要です。

不要なスレッドの生成はメモリや処理能力を無駄に消費するため、必要なタスクのみにスレッドを割り当てることが望ましいです。

また、使用しなくなったスレッドは適切に終了させ、リソースを解放することも重要です。

リソースの効率的な利用のためには、スレッドプールの使用が推奨されます。

スレッドプールでは、事前に定義された数のスレッドを生成し、それらを再利用することで、スレッドの生成と破棄に伴うオーバーヘッドを減らすことができます。

また、タスクのキューイングと効率的なタスクの割り当てにより、リソースの使用を最適化することが可能です。

●std::thread::joinのカスタマイズ方法

C++のマルチスレッドプログラミングにおいて、std::thread::joinは非常に重要な機能です。

このメソッドは、作成されたスレッドが終了するのを待つために使用されます。

通常、std::thread::joinはスレッドがそのタスクを完了するまで現在のスレッドの実行をブロックします。

しかし、特定の状況では、joinの挙動をカスタマイズする必要があるかもしれません。

例えば、タイムアウトを設定してスレッドが長時間実行されるのを避けたり、特定の条件下でのみjoinを呼び出したい場合などです。

std::threadをカスタマイズする一つの方法は、独自のスレッドラッパークラスを作成することです。

このクラスはstd::threadを内部に持ち、joinメソッドの挙動を変更できるようにします。

例えば、タイムアウト機能を持たせたjoinメソッドを実装することが可能です。

このようなクラスは、スレッドのより細かい制御を必要とする複雑なマルチスレッドアプリケーションで役立つでしょう。

○カスタムスレッドクラスの作成

独自のスレッドクラスを作成することで、std::threadの機能を拡張し、joinメソッドの挙動をカスタマイズすることができます。

#include <thread>
#include <chrono>
#include <iostream>

class CustomThread {
public:
    CustomThread() = default;

    template <typename Callable, typename... Args>
    CustomThread(Callable&& func, Args&&... args)
        : thread_(std::forward<Callable>(func), std::forward<Args>(args)...) {}

    ~CustomThread() {
        if (thread_.joinable()) {
            join();
        }
    }

    void join() {
        // ここでカスタマイズされたjoinの挙動を実装する
        // 例：特定のタイミングでjoinを呼び出す、タイムアウトを設定する等
        thread_.join();
    }

private:
    std::thread thread_;
};

void threadFunction() {
    std::this_thread::sleep_for(std::chrono::seconds(1));
    std::cout << "Thread function executed\n";
}

int main() {
    CustomThread myThread(threadFunction);
    // ここで他の処理を実行する
    // ...

    // スレッドが終了するのを待つ
    myThread.join();

    return 0;
}

このコードでは、CustomThreadクラスを定義し、std::threadの機能をラップしています。

このクラスでは、デストラクタ内でjoinを呼び出し、スレッドが終了するのを確実に待つようにしています。

また、joinメソッド内ではカスタマイズされた挙動を実装することができます。

例えば、タイムアウトを設定することで、スレッドが一定時間以上実行されるのを防ぐことが可能です。

○joinの挙動をカスタマイズする

joinの挙動をカスタマイズするもう一つの方法は、条件付きです。

この方法を使用すると、スレッドの終了を待つ際に、特定のイベントや状態の変化をトリガーとして利用できます。

#include <thread>
#include <mutex>
#include <condition_variable>
#include <iostream>

class ConditionalJoinThread {
public:
    ConditionalJoinThread() = default;

    template <typename Callable, typename... Args>
    ConditionalJoinThread(Callable&& func, Args&&... args)
        : thread_(std::forward<Callable>(func), std::forward<Args>(args)...) {}

    ~ConditionalJoinThread() {
        if (thread_.joinable()) {
            join();
        }
    }

    void notify() {
        {
            std::lock_guard<std::mutex> lock(mutex_);
            ready_ = true;
        }
        condition_.notify_one();
    }

    void join() {
        std::unique_lock<std::mutex> lock(mutex_);
        condition_.wait(lock, [this]{ return ready_; });
        thread_.join();
    }

private:
    std::thread thread_;
    std::mutex mutex_;
    std::condition_variable condition_;
    bool ready_ = false;
};

void threadFunction(ConditionalJoinThread& notifier) {
    // 何らかの処理を実行
    std::this_thread::sleep_for(std::chrono::seconds(1));
    std::cout << "Thread function executed\n";

    // 処理が完了したらメインスレッドに通知
    notifier.notify();
}

int main() {
    ConditionalJoinThread myThread(threadFunction, std::ref(myThread));

    // 他の処理を実行する
    // ...

    // スレッドが特定の条件を満たしたときに終了するのを待つ
    myThread.join();

    return 0;
}

このコード例では、ConditionalJoinThreadクラスを使用しています。

このクラスはstd::threadをラップし、スレッドが特定の条件を満たしたときにのみjoinを呼び出すように設計されています。

この例では、スレッドが処理を完了し、notifyメソッドを呼び出すと、メインスレッドがjoinを呼び出してスレッドの終了を待ちます。

条件付き変数とミューテックスを使用することで、このような挙動を実現しています。

まとめ

本記事では、C++のstd::thread::joinについて、基本から応用、カスタマイズ方法に至るまで詳細に解説しました。

初心者から上級者まで理解しやすいように、サンプルコードを用いて具体的な使用方法を紹介しました。

joinメソッドの標準的な使い方から、複数スレッドの同時join、例外処理の組み込み、カスタムスレッドクラスの作成、さらにはjoinの挙動のカスタマイズまで、幅広いテーマを網羅しました。

今回解説してきた内容を基にすることで、C++でのマルチスレッドプログラミングの理解が深まり、より効率的で安定したコードの実装が可能になることでしょう。