Multithreading-Optimierungstechniken in C++

Mit der Entwicklung der Computertechnologie und der Verbesserung der Hardwareleistung ist die Multithreading-Technologie zu einer wesentlichen Fähigkeit für die moderne Programmierung geworden. C++ ist eine klassische Programmiersprache, die auch viele leistungsstarke Multithreading-Technologien bereitstellt. In diesem Artikel werden einige Multithreading-Optimierungstechniken in C++ vorgestellt, um den Lesern zu helfen, die Multithreading-Technologie besser anzuwenden.

1. Verwenden Sie std::thread

C++11 führte std::thread ein, das die Multithreading-Technologie direkt in die Standardbibliothek integriert. Das Erstellen eines neuen Threads mit std::thread ist sehr einfach. Übergeben Sie einfach einen Funktionszeiger. Zum Beispiel:

#include <thread>
#include <iostream>

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

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

Der obige Code erstellt einen neuen Thread t, führt die Hallo-Funktion aus und wartet auf den Abschluss von Thread t. Beachten Sie, dass das Erstellen und Zerstören von Threads einen gewissen Overhead erfordert, sodass std::thread rational verwendet werden muss.

2. Verwenden Sie std::async

std::async ist eine weitere praktische Multithreading-Technologie. Sie kann eine Funktion asynchron ausführen und ein std::future-Objekt zurückgeben. Verwenden Sie std::async, um die Ausführung asynchroner Aufgaben bequemer zu verwalten und Ergebnisse zu erhalten. Beispiel:

#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;
}

Der obige Code ruft die Add-Funktion auf, um 1+2 asynchron zu berechnen, und verwendet std::future-Objekte, um die Erfassung von Berechnungsergebnissen zu verwalten. Es ist zu beachten, dass std::async standardmäßig die Strategie std::launch::async verwendet und Funktionen in einem neuen Thread ausführt. Wenn Sie die Strategie std::launch::deferred verwenden möchten, müssen Sie sie manuell angeben. Die Verwendung der Strategie std::launch::deferred führt jedoch dazu, dass die Funktion nur ausgeführt wird, wenn std::future::get() aufgerufen wird, sodass die Auswahl von Fall zu Fall getroffen werden muss.

3. Verwenden Sie std::condition_variable

Bei der Multithread-Programmierung müssen Kommunikation und Synchronisation zwischen Threads durchgeführt werden, und std::condition_variable kann diesen Zweck sehr gut erreichen. Durch die Verwendung von std::condition_variable kann ein Thread darauf warten, dass eine bestimmte Bedingung eines anderen Threads wahr ist, wodurch eine Synchronisierung zwischen Threads erreicht wird. Zum Beispiel:

#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;
}

Der obige Code erstellt zwei Threads t1 und t2, wobei t1 wartet, bis eine Bedingungsvariable „ready“ wahr wird, während t2 die Bedingungsvariable nach einer Sekunde Wartezeit auf „true“ setzt und t1 benachrichtigt. Es ist zu beachten, dass std::condition_variable in Verbindung mit std::mutex verwendet werden muss, um zu verhindern, dass mehrere Threads gleichzeitig auf Bedingungsvariablen zugreifen.

4. Thread-Pool verwenden

Bei einer großen Anzahl kurzfristiger Aufgaben, die erstellt und ausgeführt werden müssen, werden Thread-Pools häufig verwendet, um die Programmleistung zu verbessern. Der Thread-Pool verwaltet eine bestimmte Anzahl von Threads und verwaltet die Zuweisung und Ausführung von Aufgaben. Durch die Verwendung eines Thread-Pools kann der zusätzliche Aufwand durch häufiges Erstellen und Zerstören von Threads vermieden und gleichzeitig die Vorteile von Multi-Core-CPUs voll ausgenutzt werden. Zum Beispiel:

#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;
}

Der obige Code definiert eine ThreadPool-Klasse, die mehrere Threads und eine Aufgabenwarteschlange enthält. Der Thread-Pool nimmt weiterhin Aufgaben aus der Aufgabenwarteschlange entgegen und führt sie aus, bis die Warteschlange leer ist oder der Thread-Pool stoppt. Verwenden Sie die ThreadPool::enqueue-Methode, um die Aufgabe zur Aufgabenwarteschlange hinzuzufügen und ein std::future-Objekt zurückzugeben, um die Ergebnisse der Aufgabenausführung zu verwalten.

Im Allgemeinen bietet C++ eine Vielzahl von Multithreading-Technologien, um Entwicklern dabei zu helfen, die Leistung von Multi-Core-CPUs zu nutzen und Threads und Aufgaben flexibler zu verwalten. Entwickler sollten diese Techniken angemessen nutzen, um die Programmleistung zu optimieren.

Das obige ist der detaillierte Inhalt vonMultithreading-Optimierungstechniken in C++. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!