#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++;  // 一個頂一個，穩得很！??