C++?std::thread怎么使用

這篇文章主要介紹了C++ std::thread怎么使用的相關知識，內容詳細易懂，操作簡單快捷，具有一定借鑒價值，相信大家閱讀完這篇C++ std::thread怎么使用文章都會有所收獲，下面我們一起來看看吧。

C++是一種高級編程語言，被廣泛用于開發高性能、大規模、復雜的軟件系統。其中一個強大的特性就是多線程編程，而std::thread是C++標準庫提供的多線程支持的重要組成部分。

std::thread是一個輕量級線程類，它允許程序員創建、啟動、停止、等待線程。與其他多線程庫不同，std::thread在運行時不需要顯式地創建和銷毀線程，而是通過構造和析構線程對象來完成這些操作。

一、std::thread的構造和析構

std::thread的構造函數需要傳入一個可調用對象，這個可調用對象可以是一個函數指針、一個函數對象、一個lambda表達式或一個類成員函數指針。創建線程的方式非常簡單，例如：

void my_func()
{
    // do something
}

std::thread my_thread(my_func); // 使用函數指針創建線程

線程對象創建后，它的執行路徑就已經開始了。我們可以通過std::thread對象的join()方法等待線程結束并阻塞主線程：

std::thread my_thread(my_func);
my_thread.join(); // 阻塞主線程等待子線程結束

當線程對象被銷毀時，它會自動調用析構函數，如果線程沒有被join()或detach()，則程序會終止并拋出std::terminate異常。

std::thread my_thread(my_func);
// 不調用join()或detach()
// 當my_thread對象離開作用域時會拋出std::terminate異常

二、std::thread的成員函數

std::thread類還有一些非常有用的成員函數，可以幫助我們管理線程的生命周期、獲取線程信息和控制線程行為。

1.join()和detach()
join()方法可以阻塞主線程等待子線程結束，而detach()方法則將線程對象與底層線程分離，使得線程對象的生命周期不再受限于線程的生命周期。

std::thread my_thread(my_func);
my_thread.detach(); // 分離線程，線程對象的生命周期不再受限于線程的生命周期

2.get_id()

get_id()方法返回線程對象所代表的線程的唯一標識符，這個標識符可以用來比較不同的線程對象是否代表同一個線程。

std::thread my_thread1(my_func);
std::thread my_thread2(my_func);
if (my_thread1.get_id() == my_thread2.get_id())
{
    // 不會執行到這里
}

3.hardware_concurrency()
hardware_concurrency()方法返回計算機硬件支持的并發線程數，這個值通常等于處理器的核心數。

std::cout << "可用線程數：" << std::thread::hardware_concurrency() << std::endl;

三、線程間的通信

線程間的通信是多線程編程中的一個重要問題，std::thread類提供了一些機制來幫助我們實現線程間的通信和同步。

1.std::atomic
std::atomic是一個原子類型，它可以保證對該類型的操作是原子的，即不會被其他線程中斷。std::atomic可以用于實現線程間的共享變量。

std::atomic<int> counter{0};
void my_func()
{
    counter++;
}

int main()
{
    std::thread t1(my_func);
    std::thread t2(my_func);
    t1.join();
    t2.join();
    std::cout << counter << std::endl; // 輸出2
    return 0;
}

2.std::mutex和std::lock_guard
std::mutex是一個互斥量，它可以用于實現線程間的互斥訪問。std::lock_guard是一個RAII風格的互斥量保護器，它可以在構造函數中獲取互斥量的鎖，在析構函數中釋放互斥量的鎖。

std::atomic<int> counter{0};
void my_func()
{
    counter++;
}

int main()
{
    std::thread t1(my_func);
    std::thread t2(my_func);
    t1.join();
    t2.join();
    std::cout << counter << std::endl; // 輸出2
    return 0;
}

3.std::condition_variable
std::condition_variable是一個條件變量，它可以用于實現線程間的同步。std::condition_variable通常與std::unique_lock一起使用，可以實現線程的等待和喚醒操作。

std::mutex my_mutex;
std::condition_variable my_cv;
bool ready = false;
void my_func()
{
    std::unique_lock<std::mutex> lock(my_mutex); // 獲取互斥量的鎖
    ready = true;
    my_cv.notify_one(); // 喚醒等待中的線程
}

int main()
{
    std::thread t1(my_func);
    std::unique_lock<std::mutex> lock(my_mutex);
    my_cv.wait(lock, []{return ready;}); // 等待線程的喚醒
    t1.join();
    return 0;
}

四、線程的異常處理

多線程程序中的異常處理是一個復雜的問題，std::thread類提供了一些機制來幫助我們處理線程中的異常。

1.try-catch塊
在線程函數中使用try-catch塊可以捕獲線程中的異常，防止異常影響其他線程和整個程序。

void my_func()
{
    try
    {
        // do something
    }
    catch (const std::exception& e)
    {
        // 處理異常
    }
}

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

2.std::terminate
std::terminate是一個函數，它可以用于終止程序的執行。當線程中發生未被捕獲的異常時，程序會自動調用std::terminate函數來終止程序的執行。

void my_func()
{
    throw std::runtime_error("something went wrong");
}

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

在上面的代碼中，my_func函數會拋出一個std::runtime_error異常，如果這個異常沒有被try-catch塊捕獲，程序就會調用std::terminate函數來終止程序的執行。

3.std::exception_ptr
std::exception_ptr是一個類，它可以用于保存線程中發生的異常。我們可以在主線程中調用std::exception_ptr::rethrow_exception函數來重新拋出線程中的異常。

std::exception_ptr my_exception;
void my_func()
{
    try
    {
        // do something
    }
    catch (...)
    {
        my_exception = std::current_exception(); // 保存異常
    }
}

int main()
{
    std::thread t1(my_func);
    std::thread t2(my_func);
    t1.join();
    t2.join();
    if (my_exception)
    {
        try
        {
            std::rethrow_exception(my_exception); // 重新拋出異常
        }
        catch (const std::exception& e)
        {
            // 處理異常
        }
    }
    return 0;
}

在上面的代碼中，my_func函數會捕獲任何類型的異常，并將異常保存到my_exception變量中。在主線程中，如果my_exception變量中保存了異常，我們就調用std::rethrow_exception函數重新拋出異常，并在catch塊中處理異常。

關于“C++ std::thread怎么使用”這篇文章的內容就介紹到這里，感謝各位的閱讀！相信大家對“C++ std::thread怎么使用”知識都有一定的了解，大家如果還想學習更多知識，歡迎關注億速云行業資訊頻道。