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

// ?? 線程函數(shù) - 就像一個(gè)獨(dú)立的小工人
DWORD WINAPI PrintHello(LPVOID lpParam) {
    printf("Hello from Windows thread!\n");  // ?? 打個(gè)招呼
    return0;  // ? 工作完成,安全退出
}

int main() {
    // ?? 創(chuàng)建新線程 - 就像開啟一條新的生產(chǎn)線
    HANDLE hThread = CreateThread(
        NULL,       // ?? 默認(rèn)安全屬性
        0,         // ?? 默認(rèn)棧大小
        PrintHello, // ???? 指定工人要做的工作
        NULL,       // ?? 沒有參數(shù)傳遞
        0,         // ?? 立即啟動(dòng)線程
        NULL        // ??? 不需要線程ID
    );
    
    // ? 等待線程完成 - 像等待工人完成工作
    WaitForSingleObject(hThread, INFINITE);
    
    // ?? 清理線程句柄 - 收拾好工作臺(tái)
    CloseHandle(hThread);
    return0;  // ?? 主程序圓滿完成
}

#include <pthread.h>  // ?? POSIX 線程庫頭文件
#include <stdio.h>    // ?? 標(biāo)準(zhǔn)輸入輸出

// ?? 線程執(zhí)行函數(shù) - 就像一個(gè)獨(dú)立的工作者
void* PrintHello(void* arg) {
    printf("Hello from POSIX thread!\n");  // ?? 打個(gè)招呼
    returnNULL;  // ? 工作完成，安全返回
}

int main() {
    pthread_t thread;  // ?? 聲明線程變量，像是工人的工牌

    // ?? 創(chuàng)建并啟動(dòng)新線程
    // 參數(shù)分別是：
    // 1?? 線程標(biāo)識(shí)符的指針
    // 2?? 線程屬性(NULL表示使用默認(rèn)屬性)
    // 3?? 線程將要執(zhí)行的函數(shù)
    // 4?? 傳遞給線程函數(shù)的參數(shù)
    pthread_create(&thread, NULL, PrintHello, NULL);

    // ? 等待線程完成 - 就像等待工人干完活
    pthread_join(thread, NULL);
    
    return0;  // ?? 主程序圓滿結(jié)束
}

#include <boost/thread.hpp>    // ?? Boost的線程庫
#include <iostream>           // ?? 輸入輸出流

// ?? 線程要執(zhí)行的任務(wù)函數(shù)
void PrintHello() {
    std::cout << "Hello from Boost thread!" << std::endl;  // ?? 打個(gè)招呼
}

int main() {
    // ?? 創(chuàng)建并啟動(dòng)新線程
    boost::thread t(PrintHello);  // ?? 線程開始執(zhí)行
    
    t.join();  // ? 等待線程完成
    return0;  // ?? 主程序結(jié)束
}

boost::mutex mtx;  // ?? 創(chuàng)建一個(gè)互斥鎖 - 就像一把神奇的鎖
{
    // ?? RAII方式加鎖 - 進(jìn)入?yún)^(qū)域自動(dòng)上鎖
    boost::mutex::scoped_lock lock(mtx);  
    
    // ?? 這里是受保護(hù)的代碼區(qū)域
    // ?? 只有一個(gè)線程能在同一時(shí)間進(jìn)入這里
    // ?? 可以安全地訪問共享資源
    // ?? 比如修改共享數(shù)據(jù)...
    
} // ?? 離開作用域時(shí)自動(dòng)解鎖 - 非常優(yōu)雅且安全!
  // ??? 即使發(fā)生異常也能確保解鎖

#include <iostream>     // ?? 標(biāo)準(zhǔn)輸入輸出流
#include <thread>       // ?? 線程支持
#include <mutex>        // ?? 互斥鎖支持

// ??? 保護(hù)std::cout的互斥鎖，防止輸出混亂
std::mutex cout_mutex;  

// ???? 咖啡師的工作流程
void MakeCoffee() {
    std::lock_guard<std::mutex> lock(cout_mutex);  // ?? 自動(dòng)加鎖解鎖，很安全!
    std::cout << "? 正在煮咖啡..." << std::endl;  // ?? 安全地輸出信息
}

// ???? 茶師的工作流程
void MakeTea() {
    std::lock_guard<std::mutex> lock(cout_mutex);  // ?? 獲取輸出權(quán)限
    std::cout << "?? 正在泡茶..." << std::endl;    // ?? 安全地輸出信息
}

int main() {
    // ?? 開啟兩條并行的工作流水線
    std::thread coffee_master(MakeCoffee);    // ?? 啟動(dòng)咖啡師的線程
    std::thread tea_master(MakeTea);          // ?? 啟動(dòng)茶師的線程
    
    // ? 等待兩位師傅完成他們的工作
    coffee_master.join();    // ?? 等待咖啡師
    tea_master.join();       // ?? 等待茶師
    
    return0;  // ?? 圓滿完成！
}

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

// ?? 我們需要這些工具來協(xié)調(diào)咖啡師和茶師的工作
std::mutex mtx;                    // ?? 互斥鎖：就像休息室的門鎖
std::condition_variable cv;        // ?? 條件變量：像是咖啡師和茶師之間的對(duì)講機(jī)
bool coffee_ready = false;         // ?? 狀態(tài)標(biāo)志：咖啡完成的信號(hào)

void BaristaMakeCoffee() {
    // 第一步：宣布開始工作 ??
    {
        std::lock_guard<std::mutex> lock(mtx);    // ?? 先鎖門
        std::cout << "咖啡師: 開始煮咖啡..." << std::endl;
    }   // ?? 自動(dòng)解鎖，其他人可以用輸出了

    // 第二步：認(rèn)真煮咖啡 ??
    std::this_thread::sleep_for(std::chrono::seconds(2));  // ? 煮咖啡需要時(shí)間

    // 第三步：完成并通知茶師 ??
    {
        std::lock_guard<std::mutex> lock(mtx);
        coffee_ready = true;   // ?? 設(shè)置完成標(biāo)志
        std::cout << "咖啡師: 咖啡準(zhǔn)備好了! ??" << std::endl;
    }
    cv.notify_one();  // ?? 給茶師發(fā)消息
}

void TeaMasterWaitAndMakeTea() {
    // 第一步：等待咖啡師的信號(hào) ??
    {
        std::unique_lock<std::mutex> lock(mtx);   // ?? 特殊的鎖，可以被條件變量解開
        cv.wait(lock, [] { return coffee_ready; });  // ?? 等待咖啡完成信號(hào)
    }

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

    std::this_thread::sleep_for(std::chrono::seconds(1));  // ?? 泡茶也需要時(shí)間

    // 第三步：完成泡茶 ?
    {
        std::lock_guard<std::mutex> lock(mtx);
        std::cout << "茶師: 茶也準(zhǔn)備好了! ??" << std::endl;
    }
}

int main() {
    std::cout << "?? 咖啡廳開始營業(yè)..." << std::endl;

    // ?? 安排兩位師傅開始工作
    std::thread barista(BaristaMakeCoffee);       // ???? 咖啡師上崗
    std::thread tea_master(TeaMasterWaitAndMakeTea); // ???? 茶師上崗

    // ?? 等待工作完成
    barista.join();    // ?? 等咖啡師完成
    tea_master.join(); // ?? 等茶師完成

    std::cout << "?? 今天的飲品都準(zhǔn)備完成啦!" << std::endl;
    return 0;

// 看看這個(gè)超級(jí)管家是怎么工作的 ??
std::mutex m1, m2, m3;  // 三把小鎖 ??
{
    std::scoped_lock locks(m1, m2, m3);  // 交給管家，一切都搞定！
    // 安心寫代碼... ??
}  // 管家會(huì)自動(dòng)幫我們解鎖，貼心！ ?

std::shared_mutex party_room; ??
// 讀者們可以一起嗨！ ????
{
    std::shared_lock<std::shared_mutex> group_entry(party_room);
    // 大家一起讀數(shù)據(jù)，熱鬧！ ??
}
// 寫者需要包場(chǎng) ??
{
    std::unique_lock<std::shared_mutex> vip_entry(party_room);
    // 獨(dú)自修改數(shù)據(jù)，安靜... ??
}

// 來看看這個(gè)智能線程有多聰明 ??
void future_threads() {
    std::jthread smart_worker([](std::stop_token stoken) {
        while (!stoken.stop_requested()) {  // 隨時(shí)準(zhǔn)備停車！ ??
            // 干活ing... ????
        }
    });
    // 不用管它，下班自己會(huì)收工！ ??
}

generator<int> fibonacci() {  // 數(shù)學(xué)界的魔術(shù)師 ??
    int a = 0, b = 1;
    while (true) {
        co_yield a;  // 變個(gè)魔術(shù)，產(chǎn)生下一個(gè)數(shù)！ ?
        auto tmp = a;
        a = b;
        b = tmp + b;
    }
}

// ? 不推薦
void process_items(const std::vector<Item>& items) {
    std::vector<std::thread> threads;
    // 每個(gè)任務(wù)都開一個(gè)新線程，CPU: 我太難了! ??
    for (constauto& item : items) {
        threads.emplace_back([&item]{ process(item); });
    }
}

// ? 推薦
void process_items(const std::vector<Item>& items) {
    // 讓CPU告訴我們它能同時(shí)處理多少線程 ??
    constauto thread_count = std::thread::hardware_concurrency();
    ThreadPool pool(thread_count);  // 建個(gè)溫馨的線程小家庭 ??
    
    // 往線程池丟任務(wù)，它自己會(huì)安排得明明白白的 ??
    for (constauto& item : items) {
        pool.enqueue([&item]{ process(item); });
    }
}

// 這個(gè)計(jì)數(shù)器特別乖，不用加鎖也不會(huì)亂 ??
std::atomic<int> counter{0};  
counter++;  // 一個(gè)頂一個(gè)，穩(wěn)得很！??