[C++] Wndowsでマルチスレッド処理を実装する方法

#include <windows.h>
#include <iostream>
// スレッドで実行される関数
DWORD WINAPI ThreadFunction(LPVOID lpParam) {
    // スレッドの処理内容
    std::cout << "スレッドが実行中です。" << std::endl;
    return 0;
}
int main() {
    // スレッドハンドル
    HANDLE hThread;
    
    // スレッドの作成
    hThread = CreateThread(
        NULL,           // デフォルトのセキュリティ属性
        0,              // スレッドのスタックサイズ
        ThreadFunction, // スレッドで実行する関数
        NULL,           // スレッド関数に渡す引数
        0,              // スレッドの作成オプション
        NULL            // スレッドID
    );
    // スレッドが正常に作成されたか確認
    if (hThread != NULL) {
        // スレッドの終了を待機
        WaitForSingleObject(hThread, INFINITE);
        // スレッドハンドルを閉じる
        CloseHandle(hThread);
    } else {
        std::cerr << "スレッドの作成に失敗しました。" << std::endl;
    }
    return 0;
}

スレッドが実行中です。

#include <windows.h>
#include <iostream>
// ミューテックスのハンドル
HANDLE hMutex;
// スレッドで実行される関数
DWORD WINAPI ThreadFunction(LPVOID lpParam) {
    // ミューテックスを取得
    WaitForSingleObject(hMutex, INFINITE);
    
    // クリティカルセクション
    std::cout << "スレッドがクリティカルセクションに入ります。" << std::endl;
    Sleep(1000); // 処理のシミュレーション
    std::cout << "スレッドがクリティカルセクションから出ます。" << std::endl;
    
    // ミューテックスを解放
    ReleaseMutex(hMutex);
    return 0;
}
int main() {
    // ミューテックスの作成
    hMutex = CreateMutex(NULL, FALSE, NULL);
    
    // スレッドの作成
    HANDLE hThread1 = CreateThread(NULL, 0, ThreadFunction, NULL, 0, NULL);
    HANDLE hThread2 = CreateThread(NULL, 0, ThreadFunction, NULL, 0, NULL);
    // スレッドの終了を待機
    WaitForSingleObject(hThread1, INFINITE);
    WaitForSingleObject(hThread2, INFINITE);
    // ハンドルを閉じる
    CloseHandle(hThread1);
    CloseHandle(hThread2);
    CloseHandle(hMutex);
    return 0;
}

スレッドがクリティカルセクションに入ります。
スレッドがクリティカルセクションから出ます。
スレッドがクリティカルセクションに入ります。
スレッドがクリティカルセクションから出ます。

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

スレッドが実行中です。

#include <iostream>
#include <thread>
#include <mutex>
// ミューテックスのインスタンス
std::mutex myMutex;
// スレッドで実行される関数
void ThreadFunction() {
    // ミューテックスをロック
    myMutex.lock();
    
    // クリティカルセクション
    std::cout << "スレッドがクリティカルセクションに入ります。" << std::endl;
    std::this_thread::sleep_for(std::chrono::seconds(1)); // 処理のシミュレーション
    std::cout << "スレッドがクリティカルセクションから出ます。" << std::endl;
    
    // ミューテックスをアンロック
    myMutex.unlock();
}
int main() {
    // スレッドの作成
    std::thread thread1(ThreadFunction);
    std::thread thread2(ThreadFunction);
    // スレッドの終了を待機
    thread1.join();
    thread2.join();
    return 0;
}

スレッドがクリティカルセクションに入ります。
スレッドがクリティカルセクションから出ます。
スレッドがクリティカルセクションに入ります。
スレッドがクリティカルセクションから出ます。

#include <iostream>
#include <thread>
#include <mutex>
// ミューテックスのインスタンス
std::mutex myMutex;
// スレッドで実行される関数
void ThreadFunction() {
    // lock_guardを使用してミューテックスをロック
    std::lock_guard<std::mutex> lock(myMutex);
    
    // クリティカルセクション
    std::cout << "スレッドがクリティカルセクションに入ります。" << std::endl;
    std::this_thread::sleep_for(std::chrono::seconds(1)); // 処理のシミュレーション
    std::cout << "スレッドがクリティカルセクションから出ます。" << std::endl;
}
int main() {
    // スレッドの作成
    std::thread thread1(ThreadFunction);
    std::thread thread2(ThreadFunction);
    // スレッドの終了を待機
    thread1.join();
    thread2.join();
    return 0;
}

スレッドがクリティカルセクションに入ります。
スレッドがクリティカルセクションから出ます。
スレッドがクリティカルセクションに入ります。
スレッドがクリティカルセクションから出ます。

#include <iostream>
#include <thread>
// 共有カウンタ
int counter = 0;
// スレッドで実行される関数
void IncrementCounter() {
    for (int i = 0; i < 1000; ++i) {
        ++counter; // 競合状態が発生する可能性がある
    }
}
int main() {
    std::thread thread1(IncrementCounter);
    std::thread thread2(IncrementCounter);
    thread1.join();
    thread2.join();
    std::cout << "最終カウンタの値: " << counter << std::endl;
    return 0;
}

最終カウンタの値: 1999

#include <iostream>
#include <thread>
#include <mutex>
// 共有カウンタ
int counter = 0;
// ミューテックスのインスタンス
std::mutex myMutex;
// スレッドで実行される関数
void IncrementCounter() {
    for (int i = 0; i < 1000; ++i) {
        std::lock_guard<std::mutex> lock(myMutex); // ミューテックスをロック
        ++counter; // クリティカルセクション
    }
}
int main() {
    std::thread thread1(IncrementCounter);
    std::thread thread2(IncrementCounter);
    thread1.join();
    thread2.join();
    std::cout << "最終カウンタの値: " << counter << std::endl;
    return 0;
}

最終カウンタの値: 2000

#include <iostream>
#include <thread>
#include <vector>
#include <queue>
#include <mutex>
#include <condition_variable>
#include <functional>
class ThreadPool {
public:
    ThreadPool(size_t numThreads);
    ~ThreadPool();
    void enqueue(std::function<void()> task);
private:
    std::vector<std::thread> workers;
    std::queue<std::function<void()>> tasks;
    std::mutex queueMutex;
    std::condition_variable condition;
    bool stop;
};
ThreadPool::ThreadPool(size_t numThreads) : stop(false) {
    for (size_t i = 0; i < numThreads; ++i) {
        workers.emplace_back([this] {
            for (;;) {
                std::function<void()> task;
                {
                    std::unique_lock<std::mutex> lock(this->queueMutex);
                    this->condition.wait(lock, [this] { return this->stop || !this->tasks.empty(); });
                    if (this->stop && this->tasks.empty()) return;
                    task = std::move(this->tasks.front());
                    this->tasks.pop();
                }
                task();
            }
        });
    }
}
ThreadPool::~ThreadPool() {
    {
        std::unique_lock<std::mutex> lock(queueMutex);
        stop = true;
    }
    condition.notify_all();
    for (std::thread &worker : workers) {
        worker.join();
    }
}
void ThreadPool::enqueue(std::function<void()> task) {
    {
        std::unique_lock<std::mutex> lock(queueMutex);
        tasks.emplace(std::move(task));
    }
    condition.notify_one();
}
int main() {
    ThreadPool pool(4); // 4つのスレッドを持つプール
    for (int i = 0; i < 10; ++i) {
        pool.enqueue([i] {
            std::cout << "タスク " << i << " が実行中です。" << std::endl;
        });
    }
    return 0;
}

タスク 0 が実行中です。
タスク 1 が実行中です。
タスク 2 が実行中です。
タスク 3 が実行中です。
タスク 4 が実行中です。
タスク 5 が実行中です。
タスク 6 が実行中です。
タスク 7 が実行中です。
タスク 8 が実行中です。
タスク 9 が実行中です。

#include <iostream>
#include <future>
#include <chrono>
// 時間のかかる処理をシミュレートする関数
int longRunningTask() {
    std::this_thread::sleep_for(std::chrono::seconds(3)); // 3秒待機
    return 42; // 結果を返す
}
int main() {
    // 非同期処理を開始
    std::future<int> result = std::async(std::launch::async, longRunningTask);
    // メインスレッドで他の処理を行う
    std::cout << "他の処理を実行中..." << std::endl;
    // 結果を取得
    std::cout << "結果: " << result.get() << std::endl; // 結果が得られるまで待機
    return 0;
}

他の処理を実行中...
結果: 42

#include <iostream>
#include <thread>
#include <vector>
#include <mutex>
// 共有データ
std::vector<int> sharedData;
std::mutex dataMutex;
// スレッドで実行される関数
void AddData(int value) {
    std::lock_guard<std::mutex> lock(dataMutex); // ミューテックスをロック
    sharedData.push_back(value); // データを追加
}
int main() {
    std::vector<std::thread> threads;
    // スレッドを生成してデータを追加
    for (int i = 0; i < 10; ++i) {
        threads.emplace_back(AddData, i);
    }
    // スレッドの終了を待機
    for (auto &thread : threads) {
        thread.join();
    }
    // 共有データの表示
    std::cout << "共有データ: ";
    for (const auto &value : sharedData) {
        std::cout << value << " ";
    }
    std::cout << std::endl;
    return 0;
}

共有データ: 0 1 2 3 4 5 6 7 8 9