【C++】スレッド管理の基礎から応用まで！5つのサンプルコードで完全解説

#include <iostream>
#include <thread>

void workerFunction(int n) {
    // 何らかのタスクを実行する
    std::cout << "スレッドから: " << n << std::endl;
}

int main() {
    std::thread worker(workerFunction, 5); // スレッドを生成し、workerFunctionを実行

    // メインスレッドで他の処理を実行することも可能
    std::cout << "メインスレッドからの出力" << std::endl;

    worker.join(); // workerスレッドが終了するまで待機

    // スレッドが終了した後の処理
    std::cout << "スレッド終了後のメインスレッドからの出力" << std::endl;

    return 0;
}

#include <iostream>
#include <thread>

void task1() {
    // 何らかの処理
    std::cout << "task1 finished\n";
}

void task2() {
    // 何らかの処理
    std::cout << "task2 finished\n";
}

int main() {
    std::thread t1(task1);
    std::thread t2(task2);

    t1.join();
    t2.join();

    std::cout << "Both tasks finished\n";
    return 0;
}

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

int main() {
    int shared_resource = 0;

    auto increment = [&shared_resource]() {
        for (int i = 0; i < 10000; ++i) {
            ++shared_resource;
        }
    };

    std::vector<std::thread> threads;
    for (int i = 0; i < 10; ++i) {
        threads.push_back(std::thread(increment));
    }

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

    std::cout << "Final value of shared resource: " << shared_resource << '\n';
    return 0;
}

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

std::mutex mtx; // ミューテックス

void safe_increment(int& value) {
    std::lock_guard<std::mutex> lock(mtx); // ミューテックスでロック
    ++value; // 安全なインクリメント
}

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

    for (int i = 0; i < 100;

 ++i) {
        threads.push_back(std::thread(safe_increment, std::ref(counter)));
    }

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

    std::cout << "Counter: " << counter << '\n';
    return 0;
}

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

void performTask(int id) {
    // 重い処理をシミュレーション
    std::this_thread::sleep_for(std::chrono::milliseconds(100 * id));
    std::cout << "Task " << id << " completed.\n";
}

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

    for (int i = 1; i <= 5; ++i) {
        threads.emplace_back(performTask, i);
    }

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

    std::cout << "All tasks completed.\n";
    return 0;
}

#include <iostream>
#include <thread>
#include <stdexcept>

void taskWithException() {
    throw std::runtime_error("Exception from thread");
}

int main() {
    std::thread t(taskWithException);

    try {
        t.join();
    } catch (const std::exception& e) {
        std::cout << "Exception caught: " << e.what() << '\n';
    }

    std::cout << "Main thread continues.\n";
    return 0;
}

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

class ThreadPool {
public:
    ThreadPool(size_t threads) : stop(false) {
        for(size_t i = 0; i < threads; ++i)
            workers.emplace_back(
                [this] {
                    for(;;) {
                        std::function<void()> task;

                        {
                            std::unique_lock<std::mutex> lock(this->queue_mutex);
                            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() {
        {
            std::unique_lock<std::mutex> lock(queue_mutex);
            stop = true;
        }
        condition.notify_all();
        for(std::thread &worker: workers)
            worker.join();
    }

    template<class F, class... Args>
    auto enqueue(F&& f, Args&&... args) 
        -> std::future<typename std::result_of<F(Args...)>::type> {
        using return_type = typename std::result_of<F(Args...)>::type;

        auto task = std::make_shared< std::packaged_task<return_type()> >(
            std::bind(std::forward<F>(f), std::forward<Args>(args)...)
        );

        std::future<return_type> res = task->get_future();
        {
            std::unique_lock<std::mutex> lock(queue_mutex);

            if(stop)
                throw std::runtime_error("enqueue on stopped ThreadPool");

            tasks.emplace([task](){ (*task)(); });
        }
        condition.notify_one();
        return res;
    }

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

    std::mutex queue_mutex;
    std::condition_variable condition;
    bool stop;
};

void exampleTask() {
    std::cout << "Processing task.\n";
}

int main() {
    ThreadPool pool(4);
    pool.enqueue(exampleTask);
    pool.enqueue(exampleTask);
    // タスクの追加と実行
    return 0;
}