C++并发编程简史：一段你不得不知道的传奇

#include <windows.h>
#include <stdio.h>

// 🧵 线程函数 - 就像一个独立的小工人
DWORD WINAPI PrintHello(LPVOID lpParam) {
    printf("Hello from Windows thread!\n");  // 👋 打个招呼
    return0;  // ✅ 工作完成,安全退出
}

int main() {
    // 🏭 创建新线程 - 就像开启一条新的生产线
    HANDLE hThread = CreateThread(
        NULL,       // 🔒 默认安全属性
        0,         // ⚖️ 默认栈大小
        PrintHello, // 👨🔧 指定工人要做的工作
        NULL,       // 📦 没有参数传递
        0,         // 🚀 立即启动线程
        NULL        // 🏷️ 不需要线程ID
    );
    
    // ⏳ 等待线程完成 - 像等待工人完成工作
    WaitForSingleObject(hThread, INFINITE);
    
    // 🧹 清理线程句柄 - 收拾好工作台
    CloseHandle(hThread);
    return0;  // 🎉 主程序圆满完成
}

#include <pthread.h>  // 🧵 POSIX 线程库头文件
#include <stdio.h>    // 📝 标准输入输出

// 🏃 线程执行函数 - 就像一个独立的工作者
void* PrintHello(void* arg) {
    printf("Hello from POSIX thread!\n");  // 👋 打个招呼
    returnNULL;  // ✅ 工作完成，安全返回
}

int main() {
    pthread_t thread;  // 📌 声明线程变量，像是工人的工牌

    // 🚀 创建并启动新线程
    // 参数分别是：
    // 1️⃣ 线程标识符的指针
    // 2️⃣ 线程属性(NULL表示使用默认属性)
    // 3️⃣ 线程将要执行的函数
    // 4️⃣ 传递给线程函数的参数
    pthread_create(&thread, NULL, PrintHello, NULL);

    // ⏳ 等待线程完成 - 就像等待工人干完活
    pthread_join(thread, NULL);
    
    return0;  // 🎉 主程序圆满结束
}

#include <boost/thread.hpp>    // 🧵 Boost的线程库
#include <iostream>           // 📝 输入输出流

// 🎯 线程要执行的任务函数
void PrintHello() {
    std::cout << "Hello from Boost thread!" << std::endl;  // 👋 打个招呼
}

int main() {
    // 🚀 创建并启动新线程
    boost::thread t(PrintHello);  // 🏃 线程开始执行
    
    t.join();  // ⏳ 等待线程完成
    return0;  // 🎉 主程序结束
}

boost::mutex mtx;  // 🔒 创建一个互斥锁 - 就像一把神奇的锁
{
    // 🎯 RAII方式加锁 - 进入区域自动上锁
    boost::mutex::scoped_lock lock(mtx);  
    
    // 🔐 这里是受保护的代码区域
    // 💫 只有一个线程能在同一时间进入这里
    // 🎭 可以安全地访问共享资源
    // 📝 比如修改共享数据...
    
} // 🔓 离开作用域时自动解锁 - 非常优雅且安全!
  // 🛡️ 即使发生异常也能确保解锁

#include <iostream>     // 📝 标准输入输出流
#include <thread>       // 🧵 线程支持
#include <mutex>        // 🔒 互斥锁支持

// 🛡️ 保护std::cout的互斥锁，防止输出混乱
std::mutex cout_mutex;  

// 👨🍳 咖啡师的工作流程
void MakeCoffee() {
    std::lock_guard<std::mutex> lock(cout_mutex);  // 🔐 自动加锁解锁，很安全!
    std::cout << "☕ 正在煮咖啡..." << std::endl;  // 📢 安全地输出信息
}

// 👩🍳 茶师的工作流程
void MakeTea() {
    std::lock_guard<std::mutex> lock(cout_mutex);  // 🔐 获取输出权限
    std::cout << "🍵 正在泡茶..." << std::endl;    // 📢 安全地输出信息
}

int main() {
    // 🏭 开启两条并行的工作流水线
    std::thread coffee_master(MakeCoffee);    // 🚀 启动咖啡师的线程
    std::thread tea_master(MakeTea);          // 🚀 启动茶师的线程
    
    // ⌛ 等待两位师傅完成他们的工作
    coffee_master.join();    // 🤝 等待咖啡师
    tea_master.join();       // 🤝 等待茶师
    
    return0;  // 🎉 圆满完成！
}

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

// 🎭 我们需要这些工具来协调咖啡师和茶师的工作
std::mutex mtx;                    // 🔒 互斥锁：就像休息室的门锁
std::condition_variable cv;        // 🚦 条件变量：像是咖啡师和茶师之间的对讲机
bool coffee_ready = false;         // 🎯 状态标志：咖啡完成的信号

void BaristaMakeCoffee() {
    // 第一步：宣布开始工作 📢
    {
        std::lock_guard<std::mutex> lock(mtx);    // 🔐 先锁门
        std::cout << "咖啡师: 开始煮咖啡..." << std::endl;
    }   // 🔓 自动解锁，其他人可以用输出了

    // 第二步：认真煮咖啡 ☕️
    std::this_thread::sleep_for(std::chrono::seconds(2));  // ⏰ 煮咖啡需要时间

    // 第三步：完成并通知茶师 📣
    {
        std::lock_guard<std::mutex> lock(mtx);
        coffee_ready = true;   // 🚀 设置完成标志
        std::cout << "咖啡师: 咖啡准备好了! 🎉" << std::endl;
    }
    cv.notify_one();  // 📱 给茶师发消息
}

void TeaMasterWaitAndMakeTea() {
    // 第一步：等待咖啡师的信号 👂
    {
        std::unique_lock<std::mutex> lock(mtx);   // 🔓 特殊的锁，可以被条件变量解开
        cv.wait(lock, [] { return coffee_ready; });  // 🚦 等待咖啡完成信号
    }

    // 第二步：开始泡茶 🍵
    {
        std::lock_guard<std::mutex> lock(mtx);
        std::cout << "茶师: 咖啡好了,我开始泡茶..." << std::endl;
    }

    std::this_thread::sleep_for(std::chrono::seconds(1));  // ⏲️ 泡茶也需要时间

    // 第三步：完成泡茶 ✨
    {
        std::lock_guard<std::mutex> lock(mtx);
        std::cout << "茶师: 茶也准备好了! 🎊" << std::endl;
    }
}

int main() {
    std::cout << "☕️ 咖啡厅开始营业..." << std::endl;

    // 🎬 安排两位师傅开始工作
    std::thread barista(BaristaMakeCoffee);       // 👨🍳 咖啡师上岗
    std::thread tea_master(TeaMasterWaitAndMakeTea); // 👩🍳 茶师上岗

    // ⌛️ 等待工作完成
    barista.join();    // 🤝 等咖啡师完成
    tea_master.join(); // 🤝 等茶师完成

    std::cout << "🏪 今天的饮品都准备完成啦!" << std::endl;
    return 0;

// 看看这个超级管家是怎么工作的 🎩
std::mutex m1, m2, m3;  // 三把小锁 🔐
{
    std::scoped_lock locks(m1, m2, m3);  // 交给管家，一切都搞定！
    // 安心写代码... 😌
}  // 管家会自动帮我们解锁，贴心！ ✨

std::shared_mutex party_room; 🎪
// 读者们可以一起嗨！ 💃🕺
{
    std::shared_lock<std::shared_mutex> group_entry(party_room);
    // 大家一起读数据，热闹！ 🎊
}
// 写者需要包场 🎭
{
    std::unique_lock<std::shared_mutex> vip_entry(party_room);
    // 独自修改数据，安静... 🤫
}

// 来看看这个智能线程有多聪明 🧠
void future_threads() {
    std::jthread smart_worker([](std::stop_token stoken) {
        while (!stoken.stop_requested()) {  // 随时准备停车！ 🚦
            // 干活ing... 👨💻
        }
    });
    // 不用管它，下班自己会收工！ 😎
}

generator<int> fibonacci() {  // 数学界的魔术师 🎩
    int a = 0, b = 1;
    while (true) {
        co_yield a;  // 变个魔术，产生下一个数！ ✨
        auto tmp = a;
        a = b;
        b = tmp + b;
    }
}

// ❌ 不推荐
void process_items(const std::vector<Item>& items) {
    std::vector<std::thread> threads;
    // 每个任务都开一个新线程，CPU: 我太难了! 😱
    for (constauto& item : items) {
        threads.emplace_back([&item]{ process(item); });
    }
}

// ✅ 推荐
void process_items(const std::vector<Item>& items) {
    // 让CPU告诉我们它能同时处理多少线程 🤖
    constauto thread_count = std::thread::hardware_concurrency();
    ThreadPool pool(thread_count);  // 建个温馨的线程小家庭 🏠
    
    // 往线程池丢任务，它自己会安排得明明白白的 📝
    for (constauto& item : items) {
        pool.enqueue([&item]{ process(item); });
    }
}

// 这个计数器特别乖，不用加锁也不会乱 🎪
std::atomic<int> counter{0};  
counter++;  // 一个顶一个，稳得很！💪