モダンC++のスレッド入門：std::jthreadの使い方と同期処理の基本を解説

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

void worker_function() {
    // 1秒間スリープして処理をシミュレート
    std::this_thread::sleep_for(std::chrono::seconds(1));
    std::cout << "Worker thread: 処理が完了しました。" << std::endl;
}

int main() {
    std::cout << "Main thread: スレッドを開始します。" << std::endl;

    // jthreadを作成。スコープを抜けるときに自動でjoinされる
    {
        std::jthread jt(worker_function);
    } 

    std::cout << "Main thread: すべての処理が終了しました。" << std::endl;
    return 0;
}

Main thread: スレッドを開始します。
Worker thread: 処理が完了しました。
Main thread: すべての処理が終了しました。

#include <iostream>
#include <thread>
#include <string>

void print_message(const std::string& msg, int count) {
    for (int i = 0; i < count; ++i) {
        std::cout << msg << " (ID: " << i << ")" << std::endl;
    }
}

int main() {
    std::string text = "Hello from jthread";
    // 引数として文字列と回数を渡す
    std::jthread jt(print_message, text, 3);
    
    return 0;
}

Hello from jthread (ID: 0)
Hello from jthread (ID: 1)
Hello from jthread (ID: 2)

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

void continuous_worker(std::stop_token stoken) {
    std::cout << "Worker: 監視を開始します。" << std::endl;

    // 外部から停止要求（stop_requested）があるまでループを継続
    while (!stoken.stop_requested()) {
        std::cout << "Worker: 実行中..." << std::endl;
        std::this_thread::sleep_for(std::chrono::milliseconds(500));
    }

    std::cout << "Worker: 停止要求を検知し、安全に終了します。" << std::endl;
}

int main() {
    std::jthread jt(continuous_worker);

    // 2秒間メインスレッドを待機
    std::this_thread::sleep_for(std::chrono::seconds(2));

    std::cout << "Main: スレッドの停止を要求します。" << std::endl;
    // request_stop()を呼び出して停止信号を送る
    jt.request_stop();

    return 0;
}

Worker: 監視を開始します。
Worker: 実行中...
Worker: 実行中...
Worker: 実行中...
Worker: 実行中...
Main: スレッドの停止を要求します。
Worker: 停止要求を検知し、安全に終了します。

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

int shared_counter = 0;
std::mutex counter_mutex;

void increment(int iterations) {
    for (int i = 0; i < iterations; ++i) {
        // ミューテックスをロック。スコープ終了時に自動解除
        std::lock_guard<std::mutex> lock(counter_mutex);
        shared_counter++;
    }
}

int main() {
    const int num_threads = 5;
    const int iterations = 10000;
    std::vector<std::jthread> threads;

    for (int i = 0; i < num_threads; ++i) {
        threads.emplace_back(increment, iterations);
    }

    // すべてのjthreadが終了するのを待機
    threads.clear(); 

    std::cout << "最終カウント結果: " << shared_counter << std::endl;
    return 0;
}

#include <mutex>

std::mutex mutexA;
std::mutex mutexB;

void process_data() {
    // 複数のミューテックスを安全に一括ロック
    std::scoped_lock lock(mutexA, mutexB);
    // ここで両方のリソースを安全に操作
}

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

// アトミックな整数型
std::atomic<int> atomic_counter{0};

void atomic_increment(int iterations) {
    for (int i = 0; i < iterations; ++i) {
        // ロックなしで安全に加算
        atomic_counter++;
    }
}

int main() {
    std::vector<std::jthread> threads;
    for (int i = 0; i < 5; ++i) {
        threads.emplace_back(atomic_increment, 10000);
    }
    
    threads.clear();
    std::cout << "アトミックカウント結果: " << atomic_counter.load() << std::endl;
    return 0;
}

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

std::queue<int> data_queue;
std::mutex queue_mutex;
std::condition_variable cv;
bool finished = false;

void producer() {
    for (int i = 1; i <= 5; ++i) {
        {
            std::lock_guard<std::mutex> lock(queue_mutex);
            data_queue.push(i);
            std::cout << "Produced: " << i << std::endl;
        }
        cv.notify_one(); // 待機中のスレッドに通知
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
    }
    
    {
        std::lock_guard<std::mutex> lock(queue_mutex);
        finished = true;
    }
    cv.notify_all();
}

void consumer() {
    while (true) {
        std::unique_lock<std::mutex> lock(queue_mutex);
        // 条件が満たされるまで待機（データの存在または終了フラグ）
        cv.wait(lock, [] { return !data_queue.empty() || finished; });

        while (!data_queue.empty()) {
            int val = data_queue.front();
            data_queue.pop();
            std::cout << "Consumed: " << val << std::endl;
        }

        if (finished) break;
    }
}

int main() {
    std::jthread p_thread(producer);
    std::jthread c_thread(consumer);
    return 0;
}