C++中的多執行緒最佳化技巧

隨著電腦技術的發展和硬體效能的提升，多執行緒技術已經成為了現代程式設計的必備技能。 C 是一門經典的程式語言，也提供了許多強大的多執行緒技術。本文將介紹C 中的一些多執行緒優化技巧，以幫助讀者更好地應用多執行緒技術。

一、使用 std::thread

C 11引進了 std::thread，將多執行緒技術直接整合到了標準函式庫中。使用 std::thread 建立一個新的執行緒非常簡單，只需要傳遞一個函數指標。例如：

#include <thread>
#include <iostream>

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

int main()
{
    std::thread t(hello);
    t.join();
    return 0;
}

上面的程式碼建立了一個新的執行緒t，執行hello函數，並等待執行緒t完成。注意，執行緒的建立和銷毀需要一定的開銷，因此需要合理地使用 std::thread。

二、使用 std::async

std::async是另一個方便的多執行緒技術，它可以非同步地執行一個函數，並傳回一個 std::future 物件。使用 std::async 可以更方便地管理非同步任務的執行和結果取得。例如：

#include <future>
#include <iostream>

int add(int a, int b)
{
    return a + b;
}

int main()
{
    auto async_result = std::async(add, 1, 2);
    std::cout << async_result.get();
    return 0;
}

上面的程式碼呼叫add函數非同步計算1 2，並使用 std::future 物件管理計算結果的取得。要注意的是，std::async 預設使用 std::launch::async 策略，會在新的執行緒中執行函式。如果希望使用 std::launch::deferred 策略，則需要手動指定。但是，使用 std::launch::deferred 策略會導致函數在呼叫 std::future::get() 時才執行，因此需要根據具體情況進行選擇。

三、使用 std::condition_variable

在多執行緒程式設計中，執行緒之間需要進行通訊和同步，而 std::condition_variable 可以很好地實現這個目的。使用 std::condition_variable 可以讓一個執行緒等待另一個執行緒的某個條件成立，從而實現執行緒之間的同步。例如：

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

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

void producer()
{
    std::unique_lock<std::mutex> lock(mutex);
    // wait for the condition to become true
    cv.wait(lock, [] { return ready; });
    std::cout << "Producer done." << std::endl;
}

void consumer()
{
    std::this_thread::sleep_for(std::chrono::seconds(1));
    ready = true;
    std::cout << "Consumer done." << std::endl;
    cv.notify_one();
}

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

上面的程式碼建立了兩個執行緒t1和t2，其中t1在等待一個條件變數ready變成true之前一直處於等待狀態，而t2則在等待1秒後設定條件變數為true，並通知t1。需要注意的是，使用 std::condition_variable 必須配合std::mutex一起使用，以防止多個執行緒同時存取條件變數的問題。

四、使用執行緒池

在大量需要建立並執行的短期任務的情況下，經常會使用執行緒池以提高程式的效能。執行緒池維護一定數量的執行緒並管理任務的分配和執行。使用執行緒池可以避免頻繁建立和銷毀執行緒的額外開銷，同時可以充分利用多核心CPU的優勢。例如：

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

class ThreadPool
{
public:
    ThreadPool(std::size_t numThreads = std::thread::hardware_concurrency())
    {
        for (std::size_t i = 0; i < numThreads; ++i)
        {
            pool.emplace_back([this] {
                while (!stop)
                {
                    std::function<void()> task;
                    {
                        std::unique_lock<std::mutex> lock{ mutex };
                        condition.wait(lock, [this] { return stop || !tasks.empty(); });
                        if (stop && tasks.empty()) return;
                        task = std::move(tasks.front());
                        tasks.pop();
                    }
                    task();
                }
            });
        }
    }

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

    template <typename F, typename... Args>
    auto enqueue(F&& f, Args&&... args)
        -> std::future<typename std::result_of<F(Args...)>::type>
    {
        using return_type = typename std::result_of<F(Args...)>::type;
        auto task = std::make_shared<std::packaged_task<return_type()>>(
            std::bind(std::forward<F>(f), std::forward<Args>(args)...));
        std::future<return_type> future = task->get_future();
        {
            std::unique_lock<std::mutex> lock{ mutex };
            if (stop) throw std::runtime_error("enqueue on stopped ThreadPool");
            tasks.emplace([task](){ (*task)(); });
        }
        condition.notify_one();
        return future;
    }

private:
    std::vector<std::thread> pool;
    std::queue<std::function<void()>> tasks;
    std::mutex mutex;
    std::condition_variable condition;
    bool stop = false;
};

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

int add(int a, int b)
{
    return a + b;
}

int main()
{
    {
        ThreadPool pool;
        auto f1 = pool.enqueue(hello);
        auto f2 = pool.enqueue(add, 1, 2);
        std::cout << f2.get() << std::endl;
    }
    return 0;
}

上面的程式碼定義了一個ThreadPool類，其中包含多個執行緒和一個任務佇列。執行緒池不斷從任務佇列中取出任務並執行，直到佇列為空或執行緒池停止。使用 ThreadPool::enqueue 方法將任務加入任務佇列，並傳回一個 std::future 物件來管理任務執行的結果。

總的來說，C 提供了多種多執行緒技術來幫助開發者發揮多核心CPU的效能，並且能夠更靈活地管理執行緒和任務。開發者應該合理地使用這些技術來優化程式效能。

以上是C++中的多執行緒最佳化技巧的詳細內容。更多資訊請關注PHP中文網其他相關文章！