#include <iostream>

int main() {
    std::cout << "一個工人要做所有工作..." << std::endl;
    std::cout << "和面 → 烤制 → 包裝" << std::endl;
    return 0;
}

// ?? 引入必要的頭文件
#include <iostream>     // 用于輸入輸出
#include <thread>      // 用于創(chuàng)建和管理線程
#include <chrono>      // 用于時間相關(guān)操作

// ???? 和面師傅的工作流程
void make_dough() {
    std::cout << "工人A: 我負(fù)責(zé)和面! ??" << std::endl;
    // ?? 模擬和面需要的時間
    // sleep_for 讓線程暫停執(zhí)行一段時間
    std::this_thread::sleep_for(std::chrono::seconds(2));
}

// ???? 烘焙師傅的工作流程
void bake() {
    std::cout << "工人B: 我負(fù)責(zé)烤制! ??" << std::endl;
    // ? 模擬烤制過程所需時間
    // 這個過程比和面要久一些
    std::this_thread::sleep_for(std::chrono::seconds(3));
}

// ?? 工廠主要運(yùn)作流程
int main() {
    std::cout << "面包工廠開工! ??" << std::endl;
    
    // ?? 創(chuàng)建兩個工人線程
    // std::thread 對象一旦創(chuàng)建，新線程立即開始執(zhí)行
    std::thread worker1(make_dough);  // ???? 和面師傅開始工作
    std::thread worker2(bake);        // ???? 烘焙師傅開始工作
    
    // ?? 等待兩個工人完成他們的工作
    // join() 會阻塞主線程，直到工人線程完成工作
    worker1.join();  // 等待和面完成
    worker2.join();  // 等待烤制完成
    
    // ?? 所有工作完成
    std::cout << "今天的生產(chǎn)任務(wù)完成! ?" << std::endl;
    return0;
}

// ?? join 使用示例
void example_join() {
    std::thread worker([]() {
        std::cout << "工人: 我在工作..." << std::endl;
        std::this_thread::sleep_for(std::chrono::seconds(2));
    });
    
    std::cout << "主管: 等待工人完成工作..." << std::endl;
    worker.join();  // 主管在這里等待工人
    std::cout << "主管: 工人已完成工作，可以進(jìn)行下一步了!" << std::endl;
}

// ?? 后勤清潔工的工作流程
// 這是一個永不停止的后臺任務(wù)
void cleanup() {
    while(true) {  // ?? 無限循環(huán) - 清潔工永遠(yuǎn)在崗
        std::cout << "后勤工人: 保持工作區(qū)整潔... ??" << std::endl;
        // ? 每5秒進(jìn)行一次清潔工作
        // 使用sleep避免CPU資源浪費
        std::this_thread::sleep_for(std::chrono::seconds(5));
    }
}

// ?? 工廠主要運(yùn)作流程
int main() {
    // ?? 創(chuàng)建清潔工線程
    std::thread cleaner(cleanup);
    
    // ??♂? detach()讓清潔工獨立工作
    // 這意味著:
    // 1. 主線程不會等待清潔工
    // 2. 清潔工會在后臺持續(xù)工作
    // 3. 程序結(jié)束時清潔工線程會自動終止
    cleaner.detach();  
    
    // ?? 主線程繼續(xù)其他工作
    std::cout << "生產(chǎn)繼續(xù)進(jìn)行,后勤工人在后臺默默工作" << std::endl;
    // ... 繼續(xù)生產(chǎn) ... 
    
    // ?? 注意: detach后的線程無法控制
    // 要小心使用detach，因為:
    // 1. 無法知道線程是否正常運(yùn)行
    // 2. 無法手動終止線程
    // 3. 資源可能無法正確釋放
}

// ?? 互斥鎖: 就像面粉桶上的"使用中"標(biāo)志
// 防止多個面包師同時使用面粉,避免混亂
std::mutex flour_mutex;  

// ?? 面粉存量: 整個面包房共享的資源
// 1000克是我們的初始庫存
int flour_amount = 1000;  

void use_flour(int amount) {
    // ??? 智能鎖: 自動管理互斥鎖的加鎖和解鎖
    // 就像自動門,進(jìn)出面粉房時自動開關(guān)
    std::lock_guard<std::mutex> lock(flour_mutex);
    
    // ?? 檢查庫存是否充足
    if (flour_amount >= amount) {
        // ?? 更新庫存
        flour_amount -= amount;
        // ?? 記錄使用情況
        std::cout << "使用了 " << amount << "克面粉,還剩 " << flour_amount << "克" << std::endl;
    } else {
        // ?? 庫存不足警告
        std::cout << "糟糕,面粉不夠啦! ??" << std::endl;
    }
    // ?? 離開作用域時,lock_guard自動解鎖
    // 讓其他面包師可以使用面粉
}

// ?? 互斥鎖：控制對共享變量的訪問
std::mutex mtx;
// ?? 條件變量：用于線程間的通信和同步
std::condition_variable dough_ready;
// ?? 狀態(tài)標(biāo)志：表示面團(tuán)是否準(zhǔn)備就緒
bool is_dough_prepared = false;

// ???? 和面師傅的工作
void prepare_dough() {
    std::cout << "開始和面..." << std::endl;
    // ?? 模擬和面需要的時間
    std::this_thread::sleep_for(std::chrono::seconds(2));
    
    {
        // ??? 使用RAII方式加鎖，確保安全地更新共享變量
        std::lock_guard<std::mutex> lock(mtx);
        is_dough_prepared = true;
    }
    // ?? 通知烤箱工人面團(tuán)已經(jīng)準(zhǔn)備好
    dough_ready.notify_one();
}

// ???? 烤箱工人的工作
void bake_bread() {
    // ?? 使用unique_lock因為條件變量需要它
    std::unique_lock<std::mutex> lock(mtx);
    // ? 等待面團(tuán)準(zhǔn)備完成
    dough_ready.wait(lock, []{ return is_dough_prepared; });
    
    // ?? 收到通知，面團(tuán)已就緒
    std::cout << "面團(tuán)準(zhǔn)備好了,開始烤制!" << std::endl;
    // ?? 烤制過程 ...
}

// ??? ThreadGuard: 線程守護(hù)者
// 使用 RAII 技術(shù)自動管理線程的生命周期
class ThreadGuard {
    // ?? 持有對線程的引用
    std::thread& t;
public:
    // ?? 構(gòu)造函數(shù): 接管線程的管理權(quán)
    explicit ThreadGuard(std::thread& t_) : t(t_) {}
    
    // ?? 析構(gòu)函數(shù): 確保線程正確結(jié)束
    ~ThreadGuard() {
        // ? 檢查線程是否可以join
        if(t.joinable()) {
            // ?? 自動join線程,防止線程懸空
            t.join();
        }
    }
    
    // ?? 禁用拷貝構(gòu)造函數(shù)
    // 防止多個對象管理同一個線程
    ThreadGuard(const ThreadGuard&) = delete;
    
    // ?? 禁用賦值運(yùn)算符
    // 確保線程管理權(quán)不會轉(zhuǎn)移
    ThreadGuard& operator=(const ThreadGuard&) = delete;
};

// ?? 使用示例:
void example() {
    std::thread worker([]() {
        // 執(zhí)行一些工作...
    });
    // ? 創(chuàng)建守護(hù)者,自動管理線程
    ThreadGuard guard(worker);
    // ?? 即使發(fā)生異常,guard析構(gòu)時也會確保worker被join
}

#include <future>  // ?? 引入異步編程支持

// ?? 使用async創(chuàng)建異步任務(wù) - 就像給面包房請了個臨時工
// std::launch::async 確保任務(wù)在新線程中執(zhí)行
auto future_bread = std::async(std::launch::async, []() {
    std::cout << "異步烤制面包中... ??" << std::endl;
    // ? 這里可以添加耗時操作,比如:
    // std::this_thread::sleep_for(std::chrono::seconds(3));
    return"新鮮出爐的面包 ??";
});

// ? 獲取異步任務(wù)的結(jié)果
// .get() 會等待任務(wù)完成 - 就像等待面包烤好
std::cout << future_bread.get() << " 準(zhǔn)備好了! ?" << std::endl;

// ?? 好處:
// 1. 不需要手動管理線程
// 2. 可以方便地獲取返回值
// 3. 異常會自動傳播
// 4. 智能地處理線程資源