#include <iostream>
#include <thread>
void threadFunction() {
    std::cout << "Hello from thread!\\\\n";
}
int main() {
    std::thread t(threadFunction);  // 創(chuàng)建線程并執(zhí)行 threadFunction
    t.join();  // 等待線程結(jié)束
    std::cout << "Hello from main!\\\\n";
    return 0;
}

#include <iostream>
#include <thread>
void printMessage(const std::string& message) {
    std::cout << message << "\\\\n";
}
int main() {
    std::thread t(printMessage, "Hello from thread!");
    t.join();
    std::cout << "Hello from main!\\\\n";
    return 0;
}

#include <iostream>
#include <thread>
#include <mutex>
#include <vector>
std::mutex mtx;  // 互斥鎖
void printNumber(int num) {
    mtx.lock();  // 加鎖
    std::cout << "Number: " << num << "\\\\n";
    mtx.unlock();  // 解鎖
}
int main() {
    std::vector<std::thread> threads;
    for (int i = 0; i < 10; ++i) {
        threads.emplace_back(printNumber, i);
    }
    for (auto& t : threads) {
        t.join();
    }
    return 0;
}

#include <iostream>
#include <thread>
#include <mutex>
#include <vector>
std::mutex mtx;
void printNumber(int num) {
    std::lock_guard<std::mutex> lock(mtx);  // 自動加鎖和解鎖
    std::cout << "Number: " << num << "\\\\n";
}
int main() {
    std::vector<std::thread> threads;
    for (int i = 0; i < 10; ++i) {
        threads.emplace_back(printNumber, i);
    }
    for (auto& t : threads) {
        t.join();
    }
    return 0;
}

#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>
std::mutex mtx;
std::condition_variable cv;
bool ready = false;
void printMessage() {
    std::**unique_lock**<std::mutex> lock(mtx);
    cv.wait(lock, []{ return ready; });  // 等待條件滿足
    std::cout << "Hello from thread!\\\\n";
}
int main() {
    std::thread t(printMessage);
    {
        std::lock_guard<std::mutex> lock(mtx);
        ready = true;  // 設(shè)置條件為 true
    }
    cv.notify_one();  // 通知等待的線程
    t.join();
    std::cout << "Hello from main!\\\\n";
    return 0;
}
相比lock_guard的優(yōu)勢：
1. 靈活性：unique_lock 支持延遲鎖定（可以先構(gòu)造對象而不立即加鎖），而 lock_guard 在構(gòu)造時就必須加鎖。這意味著你可以先創(chuàng)建 unique_lock 對象，然后根據(jù)程序邏輯需要時再調(diào)用 lock() 或 unlock() 方法進(jìn)行手動加鎖或解鎖。
2. 條件變量的支持：unique_lock 可以與標(biāo)準(zhǔn)庫中的條件變量一起使用，如 std::condition_variable，這是 lock_guard 所不具備的功能。這是因?yàn)闂l件變量需要能夠原子地釋放鎖并進(jìn)入等待狀態(tài)，這正是 unique_lock 提供的能力之一。
3. 鎖的所有權(quán)轉(zhuǎn)移：unique_lock 支持移動語義（move semantics），允許將鎖的所有權(quán)從一個 unique_lock 對象轉(zhuǎn)移到另一個對象，從而使得鎖可以在不同的作用域中傳遞。而 lock_guard 不支持這種操作，它的鎖所有權(quán)是固定的。
4. 嘗試鎖定（try-locking）：除了基本的 lock() 和 unlock() 方法外，unique_lock 還提供了 try_lock() 方法，該方法嘗試獲取鎖但不會阻塞線程，如果無法獲得鎖則立即返回失敗結(jié)果。這對于避免線程長時間阻塞非常有用。
wait第二個參數(shù)predicate謂詞的用法參見：
<https://en.cppreference.com/w/cpp/thread/condition_variable/wait>
predicate不滿足不會結(jié)束等待執(zhí)行后續(xù)語句。

#include <iostream>
#include <thread>
#include <vector>
#include <queue>
#include <mutex>
#include <condition_variable>
#include <functional>
class ThreadPool {
public:
    ThreadPool(size_t numThreads) {
        for (size_t i = 0; i < numThreads; ++i) {
            workers.emplace_back([this] {
                while (true) {
                    std::function<void()> task;
                    {
                        std::unique_lock<std::mutex> lock(this->queueMutex);
                        this->condition.wait(lock, [this] { return this->stop || !this->tasks.empty(); });
                        if (this->stop && this->tasks.empty()) return;
                        task = std::move(this->tasks.front());
                        this->tasks.pop();
                    }
                    task();
                }
            });
        }
    }
    template<class F>
    void enqueue(F&& f) {
        {
            std::unique_lock<std::mutex> lock(queueMutex);
            tasks.emplace(std::forward<F>(f));
        }
        condition.notify_one();
    }
    ~ThreadPool() {
        {
            std::unique_lock<std::mutex> lock(queueMutex);
            stop = true;
        }
        condition.notify_all();
        for (std::thread &worker : workers) {
            worker.join();
        }
    }
private:
    std::vector<std::thread> workers;
    std::queue<std::function<void()>> tasks;
    std::mutex queueMutex;
    std::condition_variable condition;
    bool stop = false;
};
int main() {
    ThreadPool pool(4);
    for (int i = 0; i < 8; ++i) {
        pool.enqueue([i] {
            std::cout << "Task " << i << " is running on thread " << std::this_thread::get_id() << "\\\\n";
        });
    }
    return 0;
}

#include <iostream>
#include <thread>
thread_local int threadLocalVar = 0;
void threadFunction(int id) {
    threadLocalVar = id;
    std::cout << "Thread " << id << " has threadLocalVar = " << threadLocalVar << "\\\\n";
}
int main() {
    std::thread t1(threadFunction, 1);
    std::thread t2(threadFunction, 2);
    t1.join();
    t2.join();
    return 0;
}

#include <iostream>
#include <future>
int compute() {
    std::this_thread::sleep_for(std::chrono::seconds(2));
    return 42;
}
int main() {
    // 啟動異步任務(wù)
    std::future<int> fut = std::async(std::launch::async, compute);
    // 獲取結(jié)果
    int result = fut.get();
    std::cout << "Result: " << result << std::endl;
    return 0;
}
//使用 std::packaged_task （包在線程函數(shù)外）------------------------------------------
#include <iostream>
#include <future>
#include <thread>
int compute() {
    std::this_thread::sleep_for(std::chrono::seconds(2));
    return 42;
}
int main() {
    // 創(chuàng)建 packaged_task 
    std::packaged_task<int()> task(compute);
    // 獲取 future
    std::future<int> fut = task.get_future();
    // 在另一個線程中執(zhí)行任務(wù)
    std::thread t(std::move(task));
    t.join();
    // 獲取結(jié)果
    int result = fut.get();
    std::cout << "Result: " << result << std::endl;
    return 0;
}
// 使用 std::promise (作為線程函數(shù)參數(shù)) -----------------------------------------------
#include <iostream>
#include <future>
#include <thread>
void compute(std::promise<int> prom) {
    std::this_thread::sleep_for(std::chrono::seconds(2));
    prom.set_value(42);
}
int main() {
    // 創(chuàng)建 promise 和 future
    std::promise<int> prom;
    std::future<int> fut = prom.get_future();
    // 在另一個線程中執(zhí)行任務(wù)
    std::thread t(compute, std::move(prom));
    // 獲取結(jié)果
    int result = fut.get();
    std::cout << "Result: " << result << std::endl;
    t.join();
    return 0;
}