C++は高性能なソフトウェア開発において重要な役割を果たしています。特に並列処理とマルチスレッドプログラミングは、処理速度の向上と効率的なリソース利用のために欠かせない技術です。本記事では、C++で配列を使った並列処理とマルチスレッドプログラミングの基礎から応用までを具体的な例を交えて詳しく解説します。
並列処理の基礎概念
並列処理とは、複数の計算を同時に実行することで、処理速度を向上させる技術です。これにより、システム全体のパフォーマンスが大幅に改善されます。並列処理は、特に大規模なデータセットの操作や計算量の多いタスクにおいて有効です。
並列処理の利点
並列処理の主な利点は以下の通りです：
- 高速化: 複数の計算を同時に行うことで、全体の処理時間を短縮します。
- 効率的なリソース利用: CPUのコアを最大限に活用することで、計算資源の無駄を減らします。
並列処理の課題
並列処理にはいくつかの課題も伴います：
- 同期の複雑さ: 複数のスレッド間でのデータ共有や競合を防ぐための同期処理が必要です。
- デバッグの困難さ: 並列処理のバグは再現が難しく、デバッグが困難です。
並列処理の基本的なアプローチ
並列処理を実現するための一般的なアプローチには以下があります：
- データ並列化: データセットを分割し、各部分を並行して処理します。
- タスク並列化: 複数のタスクを並行して実行します。
以上の基本概念を理解することで、C++における具体的な並列処理の実装に進む準備が整います。
C++での並列処理の実装方法
C++で並列処理を実装するためには、いくつかの基本的な手法があります。ここでは、最も一般的な方法を紹介します。
スレッドの作成と管理
C++11以降、標準ライブラリにスレッドのサポートが追加されました。std::threadクラスを使用してスレッドを作成し、管理することができます。
#include <iostream>
#include <thread>
void hello() {
std::cout << "Hello from thread!" << std::endl;
}
int main() {
std::thread t(hello); // スレッドを作成してhello関数を実行
t.join(); // メインスレッドがtの終了を待つ
return 0;
}マルチスレッドでのデータ共有
スレッド間でデータを共有する場合、競合を避けるために同期が必要です。std::mutexを使用してクリティカルセクションを保護します。
#include <iostream>
#include <thread>
#include <mutex>
std::mutex mtx;
int counter = 0;
void increment() {
std::lock_guard<std::mutex> lock(mtx);
++counter;
}
int main() {
std::thread t1(increment);
std::thread t2(increment);
t1.join();
t2.join();
std::cout << "Counter: " << counter << std::endl;
return 0;
}並列アルゴリズムの利用
C++17では、並列アルゴリズムが標準ライブラリに追加されました。例えば、std::for_eachを並列で実行するには、std::execution::parポリシーを使用します。
#include <iostream>
#include <vector>
#include <algorithm>
#include <execution>
int main() {
std::vector<int> vec(1000, 1);
std::for_each(std::execution::par, vec.begin(), vec.end(), [](int& n){ n *= 2; });
std::cout << "First element: " << vec[0] << std::endl;
return 0;
}これらの手法を理解することで、C++における並列処理の実装を効果的に行うことができます。次に、配列操作の並列化について詳しく見ていきます。
配列操作の並列化
配列操作を並列化することで、大規模なデータセットの処理速度を大幅に向上させることができます。ここでは、具体的な方法とそのメリットを解説します。
配列の分割とタスクの割り当て
配列を並列化する基本的な方法は、配列を複数の部分に分割し、各部分を別々のスレッドで処理することです。以下に、配列の要素を2倍にする例を示します。
#include <iostream>
#include <vector>
#include <thread>
void multiply_part(std::vector<int>& vec, int start, int end) {
for (int i = start; i < end; ++i) {
vec[i] *= 2;
}
}
int main() {
std::vector<int> vec(1000, 1);
int num_threads = 4;
std::vector<std::thread> threads;
int part_size = vec.size() / num_threads;
for (int i = 0; i < num_threads; ++i) {
int start = i * part_size;
int end = (i + 1) * part_size;
threads.emplace_back(multiply_part, std::ref(vec), start, end);
}
for (auto& t : threads) {
t.join();
}
std::cout << "First element: " << vec[0] << std::endl;
return 0;
}並列化のメリット
配列操作を並列化することには以下のようなメリットがあります：
- 処理速度の向上: 複数のスレッドで同時に処理を行うため、大規模な配列を迅速に操作できます。
- 効率的なCPU利用: CPUのコアを最大限に活用することで、計算資源を効果的に使用できます。
並列化の注意点
並列化を行う際にはいくつかの注意点があります：
- データの競合: 複数のスレッドが同じデータにアクセスする場合、競合が発生する可能性があります。これを防ぐために適切な同期が必要です。
- オーバーヘッド: スレッドの作成や管理にはオーバーヘッドが伴います。小さなデータセットの場合、並列化の効果が薄れることがあります。
C++標準ライブラリの活用
C++17以降では、標準ライブラリの並列アルゴリズムを活用することで、簡単に並列処理を実現できます。例えば、std::for_eachを使用して配列の要素を並列に処理する例です。
#include <iostream>
#include <vector>
#include <algorithm>
#include <execution>
int main() {
std::vector<int> vec(1000, 1);
std::for_each(std::execution::par, vec.begin(), vec.end(), [](int& n){ n *= 2; });
std::cout << "First element: " << vec[0] << std::endl;
return 0;
}このように、配列操作の並列化はC++で効率的なプログラムを作成するための重要な技術です。次に、マルチスレッドプログラミングの基礎について解説します。
マルチスレッドプログラミングの基礎
マルチスレッドプログラミングは、複数のスレッドを同時に実行することで、プログラムの効率と性能を向上させる技術です。ここでは、C++での基本的なマルチスレッドプログラミングの概念と実装方法について説明します。
スレッドの基本概念
スレッドとは、プロセス内で独立して実行される最小の単位です。スレッドを使用することで、複数のタスクを同時に実行できます。
マルチスレッドの利点
- 効率の向上: 複数のタスクを同時に実行することで、CPUの利用効率を最大化します。
- 応答性の向上: ユーザーインターフェースの応答性を保ちながら、バックグラウンドで重い処理を実行できます。
スレッドの作成
C++11以降、std::threadクラスを使用してスレッドを簡単に作成できます。
#include <iostream>
#include <thread>
void thread_function() {
std::cout << "Thread function is running" << std::endl;
}
int main() {
std::thread t(thread_function); // スレッドを作成して関数を実行
t.join(); // メインスレッドがtの終了を待つ
std::cout << "Main function is running" << std::endl;
return 0;
}スレッドの同期
スレッド間でデータを共有する場合、競合を避けるために同期が必要です。C++ではstd::mutexを使用してクリティカルセクションを保護します。
#include <iostream>
#include <thread>
#include <mutex>
std::mutex mtx;
int shared_data = 0;
void increment() {
std::lock_guard<std::mutex> lock(mtx);
++shared_data;
}
int main() {
std::thread t1(increment);
std::thread t2(increment);
t1.join();
t2.join();
std::cout << "Shared data: " << shared_data << std::endl;
return 0;
}デッドロックの回避
デッドロックは、複数のスレッドが互いにロックを待つことで発生する停止状態です。これを回避するためには、ロックの取得順序を統一するなどの対策が必要です。
#include <iostream>
#include <thread>
#include <mutex>
std::mutex mtx1, mtx2;
void thread1() {
std::lock(mtx1, mtx2);
std::lock_guard<std::mutex> lock1(mtx1, std::adopt_lock);
std::lock_guard<std::mutex> lock2(mtx2, std::adopt_lock);
// 安全なコード
}
void thread2() {
std::lock(mtx1, mtx2);
std::lock_guard<std::mutex> lock1(mtx1, std::adopt_lock);
std::lock_guard<std::mutex> lock2(mtx2, std::adopt_lock);
// 安全なコード
}
int main() {
std::thread t1(thread1);
std::thread t2(thread2);
t1.join();
t2.join();
return 0;
}以上のように、マルチスレッドプログラミングの基本概念と実装方法を理解することで、より効率的なC++プログラムを作成することができます。次に、スレッドの管理と同期について詳しく説明します。
スレッドの管理と同期
マルチスレッドプログラミングでは、スレッドの管理と同期が重要な課題です。適切な管理と同期を行うことで、プログラムの安定性と効率を保つことができます。
スレッドの管理
スレッドを効果的に管理するためには、以下の点に注意が必要です：
スレッドの作成と終了
スレッドは必要な時に作成し、不要になったら終了させる必要があります。スレッドの終了を待つために、std::thread::joinを使用します。
#include <iostream>
#include <thread>
void task() {
std::cout << "Task is running" << std::endl;
}
int main() {
std::thread t(task);
t.join(); // スレッドの終了を待つ
std::cout << "Main thread is finished" << std::endl;
return 0;
}スレッドのデタッチ
場合によっては、スレッドをデタッチして独立して実行させることが有効です。この場合、std::thread::detachを使用します。
#include <iostream>
#include <thread>
void task() {
std::this_thread::sleep_for(std::chrono::seconds(1));
std::cout << "Task is finished" << std::endl;
}
int main() {
std::thread t(task);
t.detach(); // スレッドをデタッチ
std::cout << "Main thread is finished" << std::endl;
std::this_thread::sleep_for(std::chrono::seconds(2)); // タスクが終了するまで待つ
return 0;
}スレッドの同期
複数のスレッドが同じデータにアクセスする場合、データの整合性を保つために同期が必要です。C++では、std::mutexやstd::lock_guardを使用して同期を実現します。
ミューテックスによる同期
std::mutexを使用してクリティカルセクションを保護します。
#include <iostream>
#include <thread>
#include <mutex>
std::mutex mtx;
int counter = 0;
void increment() {
std::lock_guard<std::mutex> lock(mtx);
++counter;
}
int main() {
std::thread t1(increment);
std::thread t2(increment);
t1.join();
t2.join();
std::cout << "Counter: " << counter << std::endl;
return 0;
}デッドロックの回避
複数のミューテックスを使用する場合、デッドロックのリスクがあります。これを回避するために、std::lockを使用して複数のミューテックスを同時にロックします。
#include <iostream>
#include <thread>
#include <mutex>
std::mutex mtx1, mtx2;
void task1() {
std::lock(mtx1, mtx2);
std::lock_guard<std::mutex> lock1(mtx1, std::adopt_lock);
std::lock_guard<std::mutex> lock2(mtx2, std::adopt_lock);
std::cout << "Task 1 is running" << std::endl;
}
void task2() {
std::lock(mtx1, mtx2);
std::lock_guard<std::mutex> lock1(mtx1, std::adopt_lock);
std::lock_guard<std::mutex> lock2(mtx2, std::adopt_lock);
std::cout << "Task 2 is running" << std::endl;
}
int main() {
std::thread t1(task1);
std::thread t2(task2);
t1.join();
t2.join();
return 0;
}スレッドの管理と同期を適切に行うことで、プログラムの安定性と効率を大幅に向上させることができます。次に、スレッドセーフなコードの書き方について説明します。
スレッドセーフなコードの書き方
マルチスレッド環境では、複数のスレッドが同時にデータにアクセスするため、スレッドセーフなコードを書くことが重要です。ここでは、スレッドセーフなコードを書くためのベストプラクティスを紹介します。
スレッドセーフなデータ構造の使用
スレッドセーフなデータ構造を使用することで、データの整合性を保ちながら並行処理を実現できます。C++標準ライブラリには、スレッドセーフなデータ構造は含まれていないため、自分でロックを管理する必要があります。
スレッドセーフなキューの例
以下に、スレッドセーフなキューの実装例を示します。
#include <queue>
#include <mutex>
#include <condition_variable>
template <typename T>
class ThreadSafeQueue {
private:
std::queue<T> queue;
std::mutex mtx;
std::condition_variable cv;
public:
void push(T value) {
std::lock_guard<std::mutex> lock(mtx);
queue.push(value);
cv.notify_one();
}
T pop() {
std::unique_lock<std::mutex> lock(mtx);
cv.wait(lock, [this]{ return !queue.empty(); });
T value = queue.front();
queue.pop();
return value;
}
};ロックのスコープを限定する
ロックを取得する範囲を最小限にすることで、デッドロックやパフォーマンスの低下を防ぎます。std::lock_guardやstd::unique_lockを使用して、ロックのスコープを限定します。
#include <iostream>
#include <thread>
#include <mutex>
std::mutex mtx;
int counter = 0;
void increment() {
{
std::lock_guard<std::mutex> lock(mtx);
++counter;
} // ロックはここで解放される
// 他の処理
}
int main() {
std::thread t1(increment);
std::thread t2(increment);
t1.join();
t2.join();
std::cout << "Counter: " << counter << std::endl;
return 0;
}状態の不変性を保つ
スレッドセーフなコードを書くためのもう一つの重要なポイントは、状態の不変性を保つことです。特定の条件が常に満たされるようにすることで、競合状態を防ぎます。
不変状態の例
以下は、スレッドセーフな方法で状態を管理する例です。
#include <iostream>
#include <thread>
#include <mutex>
class Counter {
private:
int value;
std::mutex mtx;
public:
Counter() : value(0) {}
void increment() {
std::lock_guard<std::mutex> lock(mtx);
++value;
}
int get_value() {
std::lock_guard<std::mutex> lock(mtx);
return value;
}
};
int main() {
Counter counter;
std::thread t1(&Counter::increment, &counter);
std::thread t2(&Counter::increment, &counter);
t1.join();
t2.join();
std::cout << "Counter: " << counter.get_value() << std::endl;
return 0;
}非同期操作の管理
非同期操作を管理する際には、std::futureやstd::promiseを使用して結果を取得し、処理の完了を待つことができます。
#include <iostream>
#include <thread>
#include <future>
int async_task() {
std::this_thread::sleep_for(std::chrono::seconds(1));
return 42;
}
int main() {
std::future<int> result = std::async(std::launch::async, async_task);
std::cout << "Result: " << result.get() << std::endl; // 非同期操作の完了を待つ
return 0;
}スレッドセーフなコードを書くためには、データの整合性を保つための適切な同期と、効率的なロック管理が必要です。次に、C++標準ライブラリの活用方法について解説します。
C++標準ライブラリの活用
C++標準ライブラリには、並列処理とマルチスレッドプログラミングを支援するための強力なツールが豊富に含まれています。ここでは、これらのツールを効果的に活用する方法について解説します。
標準ライブラリのスレッドサポート
C++11以降、標準ライブラリにはスレッドサポートが追加されました。std::threadを使ってスレッドを作成し、std::mutexで同期を行います。
スレッドの基本的な使い方
以下は、標準ライブラリを使ってスレッドを作成し、管理する基本的な例です。
#include <iostream>
#include <thread>
void thread_function() {
std::cout << "Thread function is running" << std::endl;
}
int main() {
std::thread t(thread_function);
t.join(); // スレッドの終了を待つ
std::cout << "Main function is running" << std::endl;
return 0;
}同期プリミティブの活用
C++標準ライブラリには、スレッド間の同期を行うためのさまざまなプリミティブが含まれています。
ミューテックス
std::mutexを使用して、クリティカルセクションを保護します。
#include <iostream>
#include <thread>
#include <mutex>
std::mutex mtx;
int counter = 0;
void increment() {
std::lock_guard<std::mutex> lock(mtx);
++counter;
}
int main() {
std::thread t1(increment);
std::thread t2(increment);
t1.join();
t2.join();
std::cout << "Counter: " << counter << std::endl;
return 0;
}条件変数
std::condition_variableを使用して、スレッド間の待機と通知を行います。
#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>
std::mutex mtx;
std::condition_variable cv;
bool ready = false;
void print_id(int id) {
std::unique_lock<std::mutex> lock(mtx);
cv.wait(lock, [] { return ready; });
std::cout << "Thread " << id << std::endl;
}
void set_ready() {
std::lock_guard<std::mutex> lock(mtx);
ready = true;
cv.notify_all();
}
int main() {
std::thread threads[10];
for (int i = 0; i < 10; ++i) {
threads[i] = std::thread(print_id, i);
}
std::this_thread::sleep_for(std::chrono::seconds(1));
set_ready();
for (auto& t : threads) {
t.join();
}
return 0;
}並列アルゴリズムの利用
C++17では、並列アルゴリズムが追加され、標準ライブラリを通じて簡単に並列処理を実装できるようになりました。
並列`std::for_each`
以下の例では、std::for_eachを並列に実行して、配列の要素を2倍にします。
#include <iostream>
#include <vector>
#include <algorithm>
#include <execution>
int main() {
std::vector<int> vec(1000, 1);
std::for_each(std::execution::par, vec.begin(), vec.end(), [](int& n) { n *= 2; });
std::cout << "First element: " << vec[0] << std::endl;
return 0;
}非同期操作の管理
C++標準ライブラリの非同期操作を管理するために、std::futureやstd::asyncを使用します。
非同期タスクの実行
以下は、std::asyncを使用して非同期にタスクを実行し、その結果を取得する例です。
#include <iostream>
#include <future>
int async_task() {
std::this_thread::sleep_for(std::chrono::seconds(1));
return 42;
}
int main() {
std::future<int> result = std::async(std::launch::async, async_task);
std::cout << "Result: " << result.get() << std::endl;
return 0;
}C++標準ライブラリの並列処理とマルチスレッドプログラミングの機能を効果的に活用することで、より効率的でスケーラブルなプログラムを作成することができます。次に、並列ソートアルゴリズムの具体的な実装例について解説します。
応用例：並列ソートアルゴリズム
並列ソートアルゴリズムは、大規模なデータセットのソートを効率的に行うための手法です。ここでは、並列ソートアルゴリズムの具体的な実装例を紹介します。
並列クイックソート
クイックソートは効率的なソートアルゴリズムの一つですが、大規模なデータセットに対しては並列化することでさらに性能を向上させることができます。以下に、並列クイックソートの実装例を示します。
#include <iostream>
#include <vector>
#include <thread>
#include <future>
#include <algorithm>
void parallel_quick_sort(std::vector<int>& vec, int left, int right) {
if (left < right) {
int pivot = vec[right];
int i = left - 1;
for (int j = left; j < right; ++j) {
if (vec[j] < pivot) {
std::swap(vec[++i], vec[j]);
}
}
std::swap(vec[++i], vec[right]);
auto left_part = std::async(std::launch::async, [&]() { parallel_quick_sort(vec, left, i - 1); });
auto right_part = std::async(std::launch::async, [&]() { parallel_quick_sort(vec, i + 1, right); });
left_part.get();
right_part.get();
}
}
int main() {
std::vector<int> vec = {10, 7, 8, 9, 1, 5};
parallel_quick_sort(vec, 0, vec.size() - 1);
for (const int& num : vec) {
std::cout << num << " ";
}
std::cout << std::endl;
return 0;
}並列マージソート
マージソートも並列化に適したアルゴリズムです。以下に、並列マージソートの実装例を示します。
#include <iostream>
#include <vector>
#include <thread>
#include <future>
#include <algorithm>
void merge(std::vector<int>& vec, int left, int mid, int right) {
int n1 = mid - left + 1;
int n2 = right - mid;
std::vector<int> L(n1), R(n2);
std::copy(vec.begin() + left, vec.begin() + mid + 1, L.begin());
std::copy(vec.begin() + mid + 1, vec.begin() + right + 1, R.begin());
int i = 0, j = 0, k = left;
while (i < n1 && j < n2) {
if (L[i] <= R[j]) {
vec[k++] = L[i++];
} else {
vec[k++] = R[j++];
}
}
while (i < n1) {
vec[k++] = L[i++];
}
while (j < n2) {
vec[k++] = R[j++];
}
}
void parallel_merge_sort(std::vector<int>& vec, int left, int right) {
if (left < right) {
int mid = left + (right - left) / 2;
auto left_part = std::async(std::launch::async, [&]() { parallel_merge_sort(vec, left, mid); });
auto right_part = std::async(std::launch::async, [&]() { parallel_merge_sort(vec, mid + 1, right); });
left_part.get();
right_part.get();
merge(vec, left, mid, right);
}
}
int main() {
std::vector<int> vec = {12, 11, 13, 5, 6, 7};
parallel_merge_sort(vec, 0, vec.size() - 1);
for (const int& num : vec) {
std::cout << num << " ";
}
std::cout << std::endl;
return 0;
}並列アルゴリズムのメリット
- 高速化: 並列化により、大規模なデータセットのソートがより迅速に行えます。
- 効率的なリソース利用: マルチコアCPUの能力を最大限に活用できます。
実装時の注意点
- スレッドのオーバーヘッド: スレッドの作成と管理にはコストがかかるため、データセットのサイズに応じた適切なスレッド数を設定することが重要です。
- データの競合: 共有データに対するアクセスを適切に同期する必要があります。
以上のように、並列ソートアルゴリズムを活用することで、C++プログラムのパフォーマンスを大幅に向上させることができます。次に、マルチスレッド環境での例外処理の方法と注意点について説明します。
例外処理とマルチスレッド
マルチスレッドプログラミングにおいて、例外処理は重要な要素です。スレッド間で発生する例外を適切に処理することで、プログラムの安定性と信頼性を保つことができます。ここでは、マルチスレッド環境での例外処理の方法と注意点を解説します。
基本的な例外処理の方法
スレッド内で例外が発生した場合、通常の例外処理と同様にtry-catchブロックを使用します。ただし、スレッドの境界を越えて例外を伝播させることはできないため、適切な処理が必要です。
#include <iostream>
#include <thread>
void task() {
try {
throw std::runtime_error("Error in thread");
} catch (const std::exception& e) {
std::cout << "Caught exception: " << e.what() << std::endl;
}
}
int main() {
std::thread t(task);
t.join();
return 0;
}例外の伝播と処理
スレッドの境界を越えて例外を伝播させるためには、std::promiseとstd::futureを使用します。これにより、スレッド内で発生した例外をメインスレッドでキャッチできます。
#include <iostream>
#include <thread>
#include <future>
void task(std::promise<void>& p) {
try {
throw std::runtime_error("Error in thread");
} catch (...) {
p.set_exception(std::current_exception());
}
}
int main() {
std::promise<void> p;
std::future<void> f = p.get_future();
std::thread t(task, std::ref(p));
try {
f.get();
} catch (const std::exception& e) {
std::cout << "Caught exception from thread: " << e.what() << std::endl;
}
t.join();
return 0;
}複数スレッドの例外処理
複数のスレッドで例外を処理する場合、それぞれのスレッドからの例外を一元管理する方法が必要です。以下に、複数スレッドの例外を収集し、メインスレッドで処理する例を示します。
#include <iostream>
#include <thread>
#include <future>
#include <vector>
void task(int id, std::promise<void>& p) {
try {
if (id % 2 == 0) {
throw std::runtime_error("Error in thread " + std::to_string(id));
}
} catch (...) {
p.set_exception(std::current_exception());
}
}
int main() {
const int num_threads = 4;
std::vector<std::thread> threads;
std::vector<std::promise<void>> promises(num_threads);
std::vector<std::future<void>> futures;
for (int i = 0; i < num_threads; ++i) {
futures.push_back(promises[i].get_future());
threads.emplace_back(task, i, std::ref(promises[i]));
}
for (auto& future : futures) {
try {
future.get();
} catch (const std::exception& e) {
std::cout << "Caught exception from thread: " << e.what() << std::endl;
}
}
for (auto& t : threads) {
t.join();
}
return 0;
}例外処理のベストプラクティス
- スレッド内で例外をキャッチ: スレッド内で発生する例外は、スレッド内でキャッチし、適切に処理することが重要です。
std::promiseとstd::futureの活用: 例外をスレッド間で伝播させるために、std::promiseとstd::futureを使用します。- 例外のログ記録: 発生した例外は適切にログに記録し、デバッグや運用時のトラブルシューティングに役立てます。
これらの方法を理解し、適用することで、マルチスレッドプログラミングにおける例外処理を効果的に行うことができます。次に、並列処理とマルチスレッドプログラミングの理解を深めるための演習問題を紹介します。
演習問題
並列処理とマルチスレッドプログラミングの理解を深めるために、いくつかの演習問題を紹介します。これらの問題に取り組むことで、実際のプログラムで並列処理とスレッドの管理をどのように行うかを学ぶことができます。
演習1: 基本的なスレッドの作成と管理
以下の要件を満たすプログラムを作成してください：
- 3つのスレッドを作成し、それぞれ異なるメッセージを出力する。
- メインスレッドが全てのスレッドの終了を待つ。
#include <iostream>
#include <thread>
void print_message(const std::string& message) {
std::cout << message << std::endl;
}
int main() {
std::thread t1(print_message, "Thread 1: Hello, World!");
std::thread t2(print_message, "Thread 2: Multithreading is fun!");
std::thread t3(print_message, "Thread 3: C++ is powerful!");
t1.join();
t2.join();
t3.join();
return 0;
}演習2: ミューテックスを使った同期
複数のスレッドから共有変数にアクセスし、競合を防ぐためにミューテックスを使用するプログラムを作成してください：
- 共有変数
counterをインクリメントするスレッドを2つ作成する。 - ミューテックスを使用して
counterへのアクセスを保護する。
#include <iostream>
#include <thread>
#include <mutex>
std::mutex mtx;
int counter = 0;
void increment() {
for (int i = 0; i < 1000; ++i) {
std::lock_guard<std::mutex> lock(mtx);
++counter;
}
}
int main() {
std::thread t1(increment);
std::thread t2(increment);
t1.join();
t2.join();
std::cout << "Counter: " << counter << std::endl;
return 0;
}演習3: 並列ソートアルゴリズムの実装
並列クイックソートアルゴリズムを実装してください：
- 配列を並列にソートする関数
parallel_quick_sortを作成する。 - スレッドを使用して並列にソートを行う。
#include <iostream>
#include <vector>
#include <thread>
#include <future>
#include <algorithm>
void parallel_quick_sort(std::vector<int>& vec, int left, int right) {
if (left < right) {
int pivot = vec[right];
int i = left - 1;
for (int j = left; j < right; ++j) {
if (vec[j] < pivot) {
std::swap(vec[++i], vec[j]);
}
}
std::swap(vec[++i], vec[right]);
auto left_part = std::async(std::launch::async, [&]() { parallel_quick_sort(vec, left, i - 1); });
auto right_part = std::async(std::launch::async, [&]() { parallel_quick_sort(vec, i + 1, right); });
left_part.get();
right_part.get();
}
}
int main() {
std::vector<int> vec = {10, 7, 8, 9, 1, 5};
parallel_quick_sort(vec, 0, vec.size() - 1);
for (const int& num : vec) {
std::cout << num << " ";
}
std::cout << std::endl;
return 0;
}演習4: 非同期操作の例外処理
非同期操作で発生する例外を適切に処理するプログラムを作成してください：
- スレッド内で例外を発生させる。
std::promiseとstd::futureを使用して、例外をメインスレッドでキャッチする。
#include <iostream>
#include <thread>
#include <future>
void task(std::promise<void>& p) {
try {
throw std::runtime_error("Error in thread");
} catch (...) {
p.set_exception(std::current_exception());
}
}
int main() {
std::promise<void> p;
std::future<void> f = p.get_future();
std::thread t(task, std::ref(p));
try {
f.get();
} catch (const std::exception& e) {
std::cout << "Caught exception from thread: " << e.what() << std::endl;
}
t.join();
return 0;
}これらの演習を通じて、並列処理とマルチスレッドプログラミングの技術を実践的に学び、理解を深めることができます。次に、本記事のまとめを行います。
まとめ
本記事では、C++における配列の並列処理とマルチスレッドプログラミングについて、基礎から応用までを詳しく解説しました。並列処理の基本概念から始まり、具体的な実装方法、スレッドの管理と同期、スレッドセーフなコードの書き方、そして並列アルゴリズムの実装例まで、多岐にわたる内容を網羅しました。
並列処理とマルチスレッドプログラミングは、高性能なソフトウェア開発において不可欠な技術です。これらの技術を習得することで、処理速度を大幅に向上させ、効率的なリソース利用が可能になります。提供された演習問題に取り組むことで、さらに理解を深め、実践的なスキルを磨いてください。
今後もC++の高度な機能を活用し、より効率的でスケーラブルなプログラムを作成していきましょう。
コメント