スレッド

[C++] マルチスレッドでプログラムを高速化する方法

C++でマルチスレッドを活用してプログラムを高速化するには、標準ライブラリのstd::threadやstd::asyncを使用します。

タスクを複数のスレッドに分割し、並列処理を行うことで効率を向上させます。

ただし、スレッド間のデータ競合を防ぐためにstd::mutexやstd::lock_guardを用いて排他制御を行う必要があります。

スレッド数はCPUコア数に基づいて調整し、過剰なスレッド生成を避けることが重要です。

また、std::threadの代わりにstd::thread_pool(C++20以降)を利用すると、スレッド管理が簡単になります。

目次から探す

C++でマルチスレッドを実現する方法
データ競合とその対策
パフォーマンス最適化のポイント
実践例：マルチスレッドを使ったプログラム
- プログラムの概要
- プログラムの説明
まとめ

C++でマルチスレッドを実現する方法

C++では、マルチスレッドプログラミングを行うために、標準ライブラリの <thread> ヘッダを使用します。

これにより、複数のスレッドを同時に実行し、プログラムのパフォーマンスを向上させることができます。

以下に、基本的なスレッドの作成方法とその使用例を示します。

スレッドの基本的な作成

C++でスレッドを作成するには、std::threadクラスを使用します。

スレッドを生成する際には、実行したい関数を指定します。

以下は、スレッドを作成して実行する簡単な例です。

#include <iostream>
#include <thread>
// スレッドで実行する関数
void threadFunction() {
    std::cout << "スレッドが実行されています。" << std::endl;
}
int main() {
    // スレッドを作成
    std::thread myThread(threadFunction);
    // メインスレッドでの処理
    std::cout << "メインスレッドが実行されています。" << std::endl;
    // スレッドの終了を待機
    myThread.join();
    return 0;
}

メインスレッドが実行されています。
スレッドが実行されています。

この例では、threadFunction という関数を別のスレッドで実行しています。

std::thread を使ってスレッドを作成し、join()メソッドでスレッドの終了を待機しています。

これにより、メインスレッドと新しいスレッドが同時に実行されることがわかります。

スレッドに引数を渡す

スレッドに引数を渡すことも可能です。

以下の例では、引数を持つ関数をスレッドで実行しています。

#include <iostream>
#include <thread>
// 引数を持つスレッドで実行する関数
void threadFunction(int id) {
    std::cout << "スレッドID: " << id << " が実行されています。" << std::endl;
}
int main() {
    // スレッドを作成し、引数を渡す
    std::thread myThread(threadFunction, 1);
    // メインスレッドでの処理
    std::cout << "メインスレッドが実行されています。" << std::endl;
    // スレッドの終了を待機
    myThread.join();
    return 0;
}

メインスレッドが実行されています。
スレッドID: 1 が実行されています。

このように、スレッドに引数を渡すことで、より柔軟なプログラムを作成することができます。

std::thread のコンストラクタに引数を追加することで、スレッドで実行する関数に必要なデータを渡すことができます。

複数のスレッドを同時に実行

複数のスレッドを同時に実行することも可能です。

以下の例では、複数のスレッドを作成し、それぞれ異なる処理を実行しています。

#include <iostream>
#include <thread>
#include <vector>
// スレッドで実行する関数
void threadFunction(int id) {
    std::cout << "スレッドID: " << id << " が実行されています。" << std::endl;
}
int main() {
    const int numThreads = 5; // スレッドの数
    std::vector<std::thread> threads; // スレッドを格納するベクター
    // スレッドを作成
    for (int i = 0; i < numThreads; ++i) {
        threads.emplace_back(threadFunction, i); // スレッドを追加
    }
    // スレッドの終了を待機
    for (auto& th : threads) {
        th.join();
    }
    return 0;
}

スレッドID: 0 が実行されています。
スレッドID: 1 が実行されています。
スレッドID: 2 が実行されています。
スレッドID: 3 が実行されています。
スレッドID: 4 が実行されています。

この例では、5つのスレッドを同時に実行し、それぞれ異なるIDを持つスレッドが処理を行っています。

std::vector を使用してスレッドを管理し、全てのスレッドが終了するのを待機しています。

C++のマルチスレッドプログラミングを利用することで、プログラムのパフォーマンスを向上させることができます。

std::thread を使用してスレッドを作成し、引数を渡したり、複数のスレッドを同時に実行したりすることが可能です。

これにより、効率的なプログラムを構築することができます。

データ競合とその対策

マルチスレッドプログラミングでは、複数のスレッドが同じデータに同時にアクセスすることがあり、これを「データ競合」と呼びます。

データ競合が発生すると、予期しない動作やバグの原因となるため、適切な対策が必要です。

ここでは、データ競合の概要とその対策方法について説明します。

データ競合の概要

データ競合は、以下の条件が満たされると発生します。

複数のスレッドが同じメモリ領域にアクセスする。
そのうちの少なくとも1つのスレッドが書き込みを行う。
同時にアクセスが行われる。

データ競合が発生すると、スレッドの実行順序によって結果が異なるため、プログラムの動作が不安定になります。

データ競合の例

以下の例では、2つのスレッドが同じ変数に対して同時に書き込みを行い、データ競合が発生しています。

#include <iostream>
#include <thread>
int sharedVariable = 0; // 共有変数
// スレッドで実行する関数
void increment() {
    for (int i = 0; i < 1000; ++i) {
        sharedVariable++; // 共有変数をインクリメント
    }
}
int main() {
    std::thread thread1(increment);
    std::thread thread2(increment);
    thread1.join();
    thread2.join();
    std::cout << "最終的な共有変数の値: " << sharedVariable << std::endl;
    return 0;
}

最終的な共有変数の値: 1000

この例では、2つのスレッドが sharedVariable を同時にインクリメントしています。

期待される最終値は2000ですが、データ競合により、実行するたびに異なる結果が得られる可能性があります。

データ競合の対策

データ競合を防ぐためには、以下の方法があります。

対策方法	説明
ミューテックス	`std::mutex` を使用して、同時アクセスを制御する。
ロックガード	`std::lock_guard` を使用して、スコープ内で自動的にロックを管理する。
アトミック変数	`std::atomic` を使用して、スレッドセーフな操作を行う。

ミューテックスを使用した対策

std::mutex を使用することで、スレッドが共有データにアクセスする際にロックをかけることができます。

以下の例では、ミューテックスを使用してデータ競合を防いでいます。

#include <iostream>
#include <thread>
#include <mutex>
int sharedVariable = 0; // 共有変数
std::mutex mtx; // ミューテックス
// スレッドで実行する関数
void increment() {
    for (int i = 0; i < 1000; ++i) {
        mtx.lock(); // ロックを取得
        sharedVariable++; // 共有変数をインクリメント
        mtx.unlock(); // ロックを解放
    }
}
int main() {
    std::thread thread1(increment);
    std::thread thread2(increment);
    thread1.join();
    thread2.join();
    std::cout << "最終的な共有変数の値: " << sharedVariable << std::endl;
    return 0;
}

最終的な共有変数の値: 2000

この例では、mtx.lock() でロックを取得し、mtx.unlock() でロックを解放しています。

これにより、同時にスレッドが sharedVariable にアクセスすることができなくなり、データ競合を防ぐことができます。

ロックガードを使用した対策

std::lock_guard を使用することで、スコープを抜ける際に自動的にロックを解放することができます。

以下の例では、ロックガードを使用してデータ競合を防いでいます。

#include <iostream>
#include <thread>
#include <mutex>
int sharedVariable = 0; // 共有変数
std::mutex mtx; // ミューテックス
// スレッドで実行する関数
void increment() {
    for (int i = 0; i < 1000; ++i) {
        std::lock_guard<std::mutex> lock(mtx); // ロックガードを使用
        sharedVariable++; // 共有変数をインクリメント
    }
}
int main() {
    std::thread thread1(increment);
    std::thread thread2(increment);
    thread1.join();
    thread2.join();
    std::cout << "最終的な共有変数の値: " << sharedVariable << std::endl;
    return 0;
}

最終的な共有変数の値: 2000

この例では、std::lock_guard を使用することで、ロックの取得と解放を自動的に管理しています。

これにより、コードが簡潔になり、ロックの解放を忘れることがなくなります。

アトミック変数を使用した対策

std::atomic を使用することで、スレッドセーフな操作を行うことができます。

以下の例では、アトミック変数を使用してデータ競合を防いでいます。

#include <iostream>
#include <thread>
#include <atomic>
std::atomic<int> sharedVariable(0); // アトミック変数
// スレッドで実行する関数
void increment() {
    for (int i = 0; i < 1000; ++i) {
        sharedVariable++; // アトミック変数をインクリメント
    }
}
int main() {
    std::thread thread1(increment);
    std::thread thread2(increment);
    thread1.join();
    thread2.join();
    std::cout << "最終的な共有変数の値: " << sharedVariable.load() << std::endl;
    return 0;
}

最終的な共有変数の値: 2000

この例では、std::atomic を使用することで、スレッド間でのデータ競合を防ぎつつ、簡潔なコードを実現しています。

アトミック変数は、スレッドセーフな操作を提供するため、ロックを使用する必要がありません。

データ競合は、マルチスレッドプログラミングにおいて避けるべき重要な問題です。

ミューテックス、ロックガード、アトミック変数などの対策を用いることで、データ競合を防ぎ、安定したプログラムを実現することができます。

適切な対策を選択し、スレッド間のデータアクセスを安全に管理しましょう。

パフォーマンス最適化のポイント

マルチスレッドプログラミングを利用することで、プログラムのパフォーマンスを向上させることができますが、適切な設計と実装が求められます。

以下では、C++におけるマルチスレッドプログラムのパフォーマンスを最適化するためのポイントをいくつか紹介します。

スレッド数の最適化

スレッドの数は、CPUのコア数に基づいて決定することが重要です。

過剰なスレッドを作成すると、コンテキストスイッチのオーバーヘッドが増加し、パフォーマンスが低下します。

一般的には、スレッド数は以下のように設定します。

CPUコア数	推奨スレッド数
1	1
2	2
4	4
8	8
16	16

スレッド数を適切に設定することで、CPUのリソースを最大限に活用できます。

スレッド間の競合を減らす

スレッド間の競合が発生すると、パフォーマンスが低下します。

データ競合を避けるために、以下の方法を検討してください。

ロックの粒度を小さくする: ロックをかける範囲を最小限にすることで、他のスレッドが同時にアクセスできる時間を増やします。
ロックフリーのデータ構造を使用する: アトミック操作やロックフリーのデータ構造を使用することで、スレッド間の競合を減らすことができます。

タスクの分割と負荷分散

タスクを適切に分割し、各スレッドに均等に負荷を分散させることが重要です。

以下の方法でタスクを分割できます。

データ分割: 大きなデータセットを複数の部分に分割し、各スレッドに処理させる。
タスクキュー: タスクをキューに入れ、スレッドが空いているときに次のタスクを取得する方式を採用する。

これにより、スレッドのアイドル時間を減らすことができます。

スレッドの再利用

スレッドを毎回新しく作成するのではなく、スレッドプールを使用してスレッドを再利用することで、オーバーヘッドを削減できます。

スレッドプールは、あらかじめ一定数のスレッドを作成し、タスクが発生した際にそのスレッドを再利用する仕組みです。

これにより、スレッドの生成と破棄にかかる時間を短縮できます。

適切な同期手法の選択

スレッド間の同期には、さまざまな手法があります。

適切な手法を選択することで、パフォーマンスを向上させることができます。

以下の手法を検討してください。

同期手法	説明
ミューテックス	共有リソースへのアクセスを制御する。
セマフォ	リソースの数を制限するために使用する。
条件変数	特定の条件が満たされるまでスレッドを待機させる。

プロファイリングとチューニング

プログラムのパフォーマンスを最適化するためには、プロファイリングツールを使用してボトルネックを特定し、チューニングを行うことが重要です。

以下のツールを活用して、プログラムの実行状況を分析しましょう。

gprof: GNUプロファイラで、関数の呼び出し回数や実行時間を測定します。
Valgrind: メモリ使用量やスレッドの競合を分析するためのツールです。
Visual Studio Profiler: Windows環境でのパフォーマンス分析に役立ちます。

C++におけるマルチスレッドプログラミングのパフォーマンスを最適化するためには、スレッド数の最適化、競合の減少、タスクの分割、スレッドの再利用、適切な同期手法の選択、プロファイリングとチューニングが重要です。

これらのポイントを考慮し、効率的なプログラムを構築しましょう。

実践例：マルチスレッドを使ったプログラム

ここでは、C++を使用してマルチスレッドプログラミングの実践例を示します。

この例では、複数のスレッドを使用して配列の要素を並列に処理し、合計を計算するプログラムを作成します。

これにより、マルチスレッドの利点を実感できるでしょう。

プログラムの概要

このプログラムでは、以下の手順で配列の合計を計算します。

配列を複数の部分に分割します。
各部分を異なるスレッドで処理し、部分合計を計算します。
最後に、部分合計を合計して最終結果を出力します。

#include <iostream>
#include <thread>
#include <vector>
// 配列の部分合計を計算する関数
void partialSum(const std::vector<int>& data, int start, int end, long long& result) {
    result = 0; // 初期化
    for (int i = start; i < end; ++i) {
        result += data[i]; // 部分合計を計算
    }
}
int main() {
    const int arraySize = 1000000; // 配列のサイズ
    std::vector<int> data(arraySize); // 配列の作成
    // 配列に値を設定
    for (int i = 0; i < arraySize; ++i) {
        data[i] = i + 1; // 1からの連続した整数
    }
    const int numThreads = 4; // スレッド数
    std::vector<std::thread> threads(numThreads); // スレッドを格納するベクター
    std::vector<long long> partialResults(numThreads); // 部分合計を格納するベクター
    // 配列を分割してスレッドを作成
    int chunkSize = arraySize / numThreads; // 各スレッドが処理する要素数
    for (int i = 0; i < numThreads; ++i) {
        int start = i * chunkSize; // 開始インデックス
        int end = (i == numThreads - 1) ? arraySize : start + chunkSize; // 終了インデックス
        threads[i] = std::thread(partialSum, std::ref(data), start, end, std::ref(partialResults[i]));
    }
    // スレッドの終了を待機
    for (auto& th : threads) {
        th.join();
    }
    // 最終合計を計算
    long long totalSum = 0;
    for (const auto& partial : partialResults) {
        totalSum += partial; // 部分合計を加算
    }
    std::cout << "配列の合計: " << totalSum << std::endl; // 結果を出力
    return 0;
}