C++中std::thread線程怎么使用

C++中std::thread線程怎么使用

在現代C++編程中，多線程編程是一個非常重要的主題。隨著硬件的發展，多核處理器已經成為主流，利用多線程可以顯著提高程序的性能。C++11引入了std::thread類，使得在C++中進行多線程編程變得更加簡單和直觀。本文將詳細介紹std::thread的使用方法，包括線程的創建、管理、同步以及一些常見的多線程編程技巧。

1. std::thread的基本用法

1.1 創建線程

在C++中，使用std::thread類可以創建一個新的線程。std::thread的構造函數接受一個可調用對象（如函數、lambda表達式、函數對象等）作為參數，并在新線程中執行該可調用對象。

#include <iostream>
#include <thread>

void hello() {
    std::cout << "Hello, World!" << std::endl;
}

int main() {
    std::thread t(hello);  // 創建一個新線程，執行hello函數
    t.join();              // 等待線程結束
    return 0;
}

在上面的例子中，std::thread t(hello)創建了一個新線程，并在該線程中執行hello函數。t.join()用于等待線程結束。

1.2 傳遞參數給線程函數

std::thread的構造函數還可以接受額外的參數，這些參數會被傳遞給線程函數。

#include <iostream>
#include <thread>

void print_message(const std::string& message) {
    std::cout << message << std::endl;
}

int main() {
    std::thread t(print_message, "Hello from thread!");
    t.join();
    return 0;
}

在這個例子中，print_message函數接受一個std::string類型的參數。std::thread的構造函數將字符串"Hello from thread!"傳遞給print_message函數。

1.3 使用lambda表達式

除了函數，std::thread還可以接受lambda表達式作為參數。

#include <iostream>
#include <thread>

int main() {
    std::thread t([]() {
        std::cout << "Hello from lambda!" << std::endl;
    });
    t.join();
    return 0;
}

在這個例子中，std::thread的構造函數接受一個lambda表達式，該表達式在新線程中執行。

1.4 線程的分離

std::thread對象可以通過detach()方法將線程與std::thread對象分離。分離后的線程將在后臺運行，不再與std::thread對象關聯。

#include <iostream>
#include <thread>

void background_task() {
    std::cout << "Background task is running..." << std::endl;
}

int main() {
    std::thread t(background_task);
    t.detach();  // 分離線程
    std::cout << "Main thread continues..." << std::endl;
    return 0;
}

在這個例子中，t.detach()將線程與std::thread對象分離，主線程繼續執行，而background_task在后臺運行。

1.5 線程的移動

std::thread對象是不可復制的，但可以移動。這意味著你可以將一個std::thread對象的所有權轉移給另一個std::thread對象。

#include <iostream>
#include <thread>

void task() {
    std::cout << "Task is running..." << std::endl;
}

int main() {
    std::thread t1(task);
    std::thread t2 = std::move(t1);  // 將t1的所有權轉移給t2
    t2.join();
    return 0;
}

在這個例子中，t1的所有權被轉移給t2，t1不再擁有線程。

2. 線程的同步

在多線程編程中，線程之間的同步是一個重要的問題。C++提供了多種同步機制，如互斥量（std::mutex）、條件變量（std::condition_variable）等。

2.1 互斥量

互斥量用于保護共享資源，防止多個線程同時訪問共享資源導致數據競爭。

#include <iostream>
#include <thread>
#include <mutex>
#include <vector>

std::mutex mtx;
int shared_data = 0;

void increment() {
    for (int i = 0; i < 100000; ++i) {
        std::lock_guard<std::mutex> lock(mtx);
        ++shared_data;
    }
}

int main() {
    std::vector<std::thread> threads;
    for (int i = 0; i < 10; ++i) {
        threads.emplace_back(increment);
    }
    for (auto& t : threads) {
        t.join();
    }
    std::cout << "Shared data: " << shared_data << std::endl;
    return 0;
}

在這個例子中，std::mutex用于保護shared_data，std::lock_guard用于自動管理互斥量的鎖定和解鎖。

2.2 條件變量

條件變量用于線程之間的通信，允許一個線程等待另一個線程完成某個條件。

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

std::mutex mtx;
std::condition_variable cv;
bool ready = false;

void wait_for_ready() {
    std::unique_lock<std::mutex> lock(mtx);
    cv.wait(lock, []() { return ready; });
    std::cout << "Ready!" << std::endl;
}

void set_ready() {
    std::this_thread::sleep_for(std::chrono::seconds(2));
    {
        std::lock_guard<std::mutex> lock(mtx);
        ready = true;
    }
    cv.notify_all();
}

int main() {
    std::thread t1(wait_for_ready);
    std::thread t2(set_ready);
    t1.join();
    t2.join();
    return 0;
}

在這個例子中，wait_for_ready線程等待set_ready線程將ready設置為true。cv.wait會阻塞線程，直到ready為true。

2.3 原子操作

C++11引入了std::atomic，用于實現無鎖的原子操作。

#include <iostream>
#include <thread>
#include <atomic>
#include <vector>

std::atomic<int> shared_data(0);

void increment() {
    for (int i = 0; i < 100000; ++i) {
        ++shared_data;
    }
}

int main() {
    std::vector<std::thread> threads;
    for (int i = 0; i < 10; ++i) {
        threads.emplace_back(increment);
    }
    for (auto& t : threads) {
        t.join();
    }
    std::cout << "Shared data: " << shared_data << std::endl;
    return 0;
}

在這個例子中，std::atomic<int>用于保護shared_data，避免了使用互斥量的開銷。

3. 線程的管理

3.1 線程的ID

每個線程都有一個唯一的ID，可以通過std::thread::get_id()獲取。

#include <iostream>
#include <thread>

void task() {
    std::cout << "Thread ID: " << std::this_thread::get_id() << std::endl;
}

int main() {
    std::thread t1(task);
    std::thread t2(task);
    t1.join();
    t2.join();
    return 0;
}

在這個例子中，std::this_thread::get_id()用于獲取當前線程的ID。

3.2 線程的數量

可以通過std::thread::hardware_concurrency()獲取系統支持的并發線程數。

#include <iostream>
#include <thread>

int main() {
    unsigned int n = std::thread::hardware_concurrency();
    std::cout << "Number of concurrent threads supported: " << n << std::endl;
    return 0;
}

3.3 線程的優先級

C++標準庫沒有直接提供設置線程優先級的方法，但可以通過平臺特定的API來實現。

#include <iostream>
#include <thread>
#include <pthread.h>

void task() {
    std::cout << "Task is running..." << std::endl;
}

int main() {
    std::thread t(task);
    pthread_t native_handle = t.native_handle();
    pthread_setschedprio(native_handle, 10);  // 設置線程優先級
    t.join();
    return 0;
}

在這個例子中，pthread_setschedprio用于設置線程的優先級。

4. 線程池

在實際應用中，頻繁地創建和銷毀線程會帶來較大的開銷。線程池是一種常見的解決方案，它預先創建一組線程，并在需要時分配任務給這些線程。

C++標準庫沒有直接提供線程池的實現，但可以通過std::thread和std::queue等工具來實現一個簡單的線程池。

#include <iostream>
#include <thread>
#include <vector>
#include <queue>
#include <functional>
#include <mutex>
#include <condition_variable>

class ThreadPool {
public:
    ThreadPool(size_t num_threads) {
        for (size_t i = 0; i < num_threads; ++i) {
            workers.emplace_back([this] {
                while (true) {
                    std::function<void()> task;
                    {
                        std::unique_lock<std::mutex> lock(this->queue_mutex);
                        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();
                }
            });
        }
    }

    ~ThreadPool() {
        {
            std::unique_lock<std::mutex> lock(queue_mutex);
            stop = true;
        }
        condition.notify_all();
        for (std::thread& worker : workers) {
            worker.join();
        }
    }

    template <class F>
    void enqueue(F&& f) {
        {
            std::unique_lock<std::mutex> lock(queue_mutex);
            tasks.emplace(std::forward<F>(f));
        }
        condition.notify_one();
    }

private:
    std::vector<std::thread> workers;
    std::queue<std::function<void()>> tasks;
    std::mutex queue_mutex;
    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() << std::endl;
        });
    }
    return 0;
}

在這個例子中，ThreadPool類實現了一個簡單的線程池。線程池預先創建了一組線程，并通過任務隊列分配任務給這些線程。

5. 總結

std::thread是C++11引入的一個強大的工具，使得多線程編程變得更加簡單和直觀。通過std::thread，我們可以輕松地創建和管理線程，并通過互斥量、條件變量等同步機制來保證線程安全。此外，線程池等高級技術可以進一步提高多線程程序的性能和可維護性。

在實際開發中，多線程編程需要謹慎處理，避免數據競爭、死鎖等問題。通過合理地使用std::thread及其相關工具，我們可以編寫出高效、可靠的多線程程序。