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

int main() {
    // 自动处理join，无需手动调用
    std::jthread t([](std::stop_token stoken) {
        // 循环判断中断请求
        while (!stoken.stop_requested()) {
            std::cout << "线程运行中..." << std::endl;
            std::this_thread::sleep_for(std::chrono::milliseconds(100));
        }
        std::cout << "线程收到中断请求，优雅退出" << std::endl;
    });

    // 主线程运行500ms
    std::this_thread::sleep_for(std::chrono::milliseconds(500));
    // 发送中断请求，jthread析构时也会自动发送
    t.request_stop();

    // 无需手动join，t析构时自动等待
    return 0;
}

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

std::mutex mtx;
int shared_data = 0;

// lock_guard 基础用法
void add() {
    for (int i = 0; i < 10000; i++) {
        std::lock_guard<std::mutex> lock(mtx); // 构造加锁
        shared_data++; // 临界区：仅持有锁的线程可访问
        // 析构自动解锁，无论函数正常返回还是异常退出
    }
}

// scoped_lock 多锁安全用法，自动避免死锁
std::mutex mtx1, mtx2;
void multi_lock_func() {
    // 同时对多个互斥量加锁，无需考虑顺序，自动避免死锁
    std::scoped_lock lock(mtx1, mtx2);
    std::cout << "多锁安全访问" << std::endl;
}

int main() {
    std::thread t1(add);
    std::thread t2(add);
    t1.join();
    t2.join();
    std::cout << "最终结果: " << shared_data << std::endl; // 输出20000，无数据竞争
    return 0;
}

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

const int MAX_QUEUE_SIZE = 5;
std::queue<int> task_queue;
std::mutex mtx;
std::condition_variable cv_producer; // 生产者等待队列有空位
std::condition_variable cv_consumer; // 消费者等待队列有数据

// 生产者：生产数据放入队列
void producer(int id) {
    int data = 0;
    while (true) {
        std::unique_lock<std::mutex> lock(mtx);
        // 队列满了，等待空位，带谓词解决虚假唤醒
        cv_producer.wait(lock, [](){ return task_queue.size() < MAX_QUEUE_SIZE; });

        // 生产数据
        task_queue.push(data);
        std::cout << "生产者" << id << "生产数据: " << data << std::endl;
        data++;

        // 通知消费者有新数据
        cv_consumer.notify_one();
        lock.unlock(); // 提前解锁，减少临界区

        std::this_thread::sleep_for(std::chrono::milliseconds(100));
    }
}

// 消费者：从队列取出数据消费
void consumer(int id) {
    while (true) {
        std::unique_lock<std::mutex> lock(mtx);
        // 队列空了，等待数据，带谓词解决虚假唤醒
        cv_consumer.wait(lock, [](){ return !task_queue.empty(); });

        // 消费数据
        int data = task_queue.front();
        task_queue.pop();
        std::cout << "消费者" << id << "消费数据: " << data << std::endl;

        // 通知生产者有空位
        cv_producer.notify_one();
        lock.unlock();

        std::this_thread::sleep_for(std::chrono::milliseconds(200));
    }
}

int main() {
    std::thread p1(producer, 1);
    std::thread c1(consumer, 1);
    std::thread c2(consumer, 2);

    p1.join();
    c1.join();
    c2.join();
    return 0;
}

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

// 线程函数中通过promise设置结果
void async_task(std::promise<int> promise) {
    try {
        int result = 100 + 200;
        // 设置结果
        promise.set_value(result);
        // 若发生异常，设置异常
        // throw std::runtime_error("任务执行失败");
    } catch (...) {
        // 捕获所有异常，设置到promise中
        promise.set_exception(std::current_exception());
    }
}

int main() {
    // 创建promise和对应的future
    std::promise<int> promise;
    std::future<int> future = promise.get_future();

    // 启动线程，将promise移动到线程中
    std::thread t(async_task, std::move(promise));

    try {
        // 阻塞等待结果，获取值，异常会在这里抛出
        int result = future.get();
        std::cout << "异步任务结果: " << result << std::endl;
    } catch (const std::exception& e) {
        std::cout << "异步任务异常: " << e.what() << std::endl;
    }

    t.join();
    return 0;
}

#include <iostream>
#include <thread>
#include <future>

int add(int a, int b) {
    return a + b;
}

int main() {
    // 包装函数，绑定future
    std::packaged_task<int(int, int)> task(add);
    std::future<int> future = task.get_future();

    // 启动线程执行任务，task不可拷贝，必须move
    std::thread t(std::move(task), 100, 200);

    // 获取结果
    std::cout << "任务结果: " << future.get() << std::endl;
    t.join();
    return 0;
}

#include <iostream>
#include <future>
#include <chrono>

int async_func() {
    std::cout << "异步任务执行，线程ID: " << std::this_thread::get_id() << std::endl;
    std::this_thread::sleep_for(std::chrono::milliseconds(500));
    return 100;
}

int main() {
    std::cout << "主线程ID: " << std::this_thread::get_id() << std::endl;

    // 正确用法1：指定async策略，确保异步执行
    std::future<int> f1 = std::async(std::launch::async, async_func);
    // 正确用法2：默认策略，必须保存future，否则会阻塞
    // std::future<int> f2 = std::async(async_func);

    // 超级大坑：临时future对象会立即析构，析构时会阻塞等待任务完成，变成同步执行
    // std::async(std::launch::async, async_func); // 这行代码会阻塞，完全失去异步效果

    std::cout << "主线程继续执行..." << std::endl;
    // 获取结果
    std::cout << "结果: " << f1.get() << std::endl;

    return 0;
}

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

// 原子计数器，无需加锁，线程安全
std::atomic<int> count = 0;

void add() {
    for (int i = 0; i < 10000; i++) {
        count++; // 原子自增，无数据竞争
        // 等价于 count.fetch_add(1, std::memory_order_seq_cst);
    }
}

int main() {
    std::thread t1(add);
    std::thread t2(add);
    t1.join();
    t2.join();
    std::cout << "最终计数: " << count << std::endl; // 输出20000
    std::cout << "是否无锁: " << count.is_lock_free() << std::endl; // 绝大多数平台输出1
    return 0;
}

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

std::atomic<bool> ready = false;
int data = 0; // 非原子变量，通过acquire-release保证可见性

void writer() {
    data = 100; // 写操作，必须在release之前
    // release操作：保证之前的所有写入都不会重排到该操作之后
    ready.store(true, std::memory_order_release);
}

void reader() {
    // acquire操作：保证之后的所有读取都不会重排到该操作之前
    while (!ready.load(std::memory_order_acquire)) {
        std::this_thread::sleep_for(std::chrono::milliseconds(10));
    }
    // 一定能看到writer线程中data=100的写入
    std::cout << "data: " << data << std::endl;
}

int main() {
    std::thread t1(writer);
    std::thread t2(reader);
    t1.join();
    t2.join();
    return 0;
}

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

// 限制最多2个线程同时执行
std::counting_semaphore<2> sem(2);

void task(int id) {
    sem.acquire(); // 获取信号量，计数-1，计数为0则阻塞
    std::cout << "线程" << id << "进入临界区" << std::endl;
    std::this_thread::sleep_for(std::chrono::milliseconds(500));
    std::cout << "线程" << id << "退出临界区" << std::endl;
    sem.release(); // 释放信号量，计数+1
}

int main() {
    std::thread threads[5];
    for (int i = 0; i < 5; i++) {
        threads[i] = std::thread(task, i+1);
    }
    for (auto& t : threads) {
        t.join();
    }
    return 0;
}

#include <mutex>

class Singleton {
public:
    // 禁用拷贝和移动
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
    Singleton(Singleton&&) = delete;
    Singleton& operator=(Singleton&&) = delete;

    // 全局唯一访问入口，线程安全
    static Singleton& get_instance() {
        static Singleton instance; // C++11后初始化线程安全
        return instance;
    }

private:
    // 私有构造函数
    Singleton() = default;
    ~Singleton() = default;
};

#include <shared_mutex>
#include <unordered_map>
#include <string>

class Cache {
private:
    std::unordered_map<std::string, std::string> data;
    mutable std::shared_mutex mtx; // mutable允许const成员函数加锁

public:
    // 读操作：加共享锁，多个线程可同时读
    std::string get(const std::string& key) const {
        std::shared_lock<std::shared_mutex> lock(mtx);
        auto it = data.find(key);
        return it != data.end() ? it->second : "";
    }

    // 写操作：加独占锁，同一时间仅一个线程可写
    void set(const std::string& key, const std::string& value) {
        std::unique_lock<std::shared_mutex> lock(mtx);
        data[key] = value;
    }

    // 删除操作：加独占锁
    void remove(const std::string& key) {
        std::unique_lock<std::shared_mutex> lock(mtx);
        data.erase(key);
    }
};