Multithread-Programmierkenntnisse in C++

Mit der kontinuierlichen Verbesserung der Computerhardware beginnt immer mehr Software, Multithreading-Technologie zu verwenden, um die Programmleistung und Reaktionsgeschwindigkeit zu verbessern. Die Sprache C++ ist eine Sprache, die Multithread-Programmierung unterstützt. In diesem Artikel werden einige Multithread-Programmiertechniken in C++ vorgestellt.

1. Verstehen Sie das Konzept des Multithreadings

Bevor wir Multithread-Programmierung durchführen, müssen wir verstehen, was Threads sind. Ein Thread ist die kleinste Einheit der Programmausführung. Er verfügt über einen eigenen Programmzähler, einen eigenen Registersatz und einen eigenen Stapel und teilt das Codesegment, das Datensegment und die Ressourcen des Prozesses. Durch die Multithread-Programmierung können wir mehrere Threads gleichzeitig ausführen, und diese Threads können gleichzeitig ausgeführt werden.

2. Verwenden Sie Mutex-Sperren, um gemeinsam genutzte Ressourcen zu schützen.

Bei der Multithread-Programmierung können mehrere Threads gleichzeitig auf dieselbe gemeinsam genutzte Ressource zugreifen. Dies kann zu Dateninkonsistenzen führen. Daher müssen wir einen Mutex verwenden, um gemeinsam genutzte Ressourcen zu schützen. Ein Mutex ist ein Synchronisationsprimitiv, das es mehreren Threads ermöglicht, dieselbe Ressource zu teilen, aber nur ein Thread kann auf die Ressource zugreifen. Die C++-Standardbibliothek stellt die Klasse std::mutex zur Unterstützung des Mutex-Sperrmechanismus bereit.

Zum Beispiel können wir den folgenden Codeausschnitt verwenden, um die Lese- und Schreibvorgänge einer Variablen zu schützen:

#include <mutex>
#include <iostream>

std::mutex mtx; // 申明一个互斥锁

int main()
{
    int count = 0;
    std::thread t1([&count]() {
        for (int i = 0; i < 1000000; i++) {
            mtx.lock(); // 加锁
            count++;
            mtx.unlock(); // 解锁
        }
    });

    std::thread t2([&count]() {
        for (int i = 0; i < 1000000; i++) {
            mtx.lock(); // 加锁
            count++;
            mtx.unlock(); // 解锁
        }
    });

    t1.join();
    t2.join();

    std::cout << "count: " << count << std::endl;
    return 0;
}

Im obigen Code schützen wir die Lese- und Schreibvorgänge der Zählvariablen, indem wir ein std::mutex-Objekt erstellen mtx. Verwenden Sie die Funktion mtx.lock(), um das mtx-Objekt zu sperren und zu verhindern, dass andere Threads auf die Zählvariable zugreifen. Mit der Funktion mtx.unlock() kann das Mtx-Objekt entsperrt werden und anderen Threads der Zugriff auf die Zählvariable ermöglicht werden.

3. Bedingungsvariablen zum Warten und Benachrichtigen von Threads verwenden

Bei der Multithread-Programmierung müssen wir manchmal warten, bis bestimmte Bedingungen erfüllt sind, bevor wir mit der Ausführung fortfahren können. In diesem Fall können Sie eine Bedingungsvariable verwenden, um auf andere Threads zu warten und diese zu benachrichtigen.

Bedingungsvariablen sind ein Synchronisationsmechanismus, der es Threads ermöglicht, auf bestimmte Ereignisse zu warten, anstatt geschäftig zu warten. Wenn ein Thread auf eine Bedingungsvariable wartet, geht er in den Ruhezustand, bis ein anderer Thread ihn über die Bedingungsvariable benachrichtigt. Die C++-Standardbibliothek stellt die Klasse std::condition_variable zur Unterstützung des Bedingungsvariablenmechanismus bereit.

Zum Beispiel können wir den folgenden Codeausschnitt verwenden, um Threads zu warten und zu benachrichtigen:

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

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

void work()
{
    std::unique_lock<std::mutex> lock(mtx);
    cv.wait(lock, [] { return is_ready; }); // 等待条件变量满足
    std::cout << "Work started!" << std::endl;
}

int main()
{
    std::thread t(work);

    std::this_thread::sleep_for(std::chrono::seconds(2));

    {
        std::lock_guard<std::mutex> lock(mtx);
        is_ready = true;
    }

    cv.notify_one(); // 通知工作线程条件变量
    t.join();
    return 0;
}

Im obigen Code erstellen wir einen Arbeitsthread t und verwenden std::unique_lock, um Protect zu mutexieren. Thread t wartet auf die Erfüllung der Bedingungsvariablen, bevor er mit der Ausführung fortfährt. Im Hauptthread verwenden wir std::lock_guard, um den Mutex zu sperren und den Wert der Variablen is_ready zu ändern, und benachrichtigen dann den Thread über cv.notify_one(), dass die t-Bedingungsvariable erfüllt wurde.

4. Verwenden Sie std::atomic, um atomare Operationen sicherzustellen.

Bei der Multithread-Programmierung ändern mehrere Threads normalerweise dieselbe Variable gleichzeitig. In diesem Fall müssen wir sicherstellen, dass die Operation an der Variablen atomar ist. Die C++-Standardbibliothek stellt den Typ std::atomic zur Unterstützung atomarer Operationen bereit. Der Typ

std::atomic kann garantieren, dass die Operation atomar ist, das heißt, sie garantiert, dass eine Reihe von Operationen unter keinen Umständen von anderen Threads unterbrochen werden. Verwenden Sie die Klasse std::atomic, um Race Conditions und andere Probleme im Zusammenhang mit Multithreading zu vermeiden.

Zum Beispiel können wir den folgenden Codeausschnitt verwenden, um die Verwendung von std::atomic zu demonstrieren:

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

std::atomic<int> counter(0); // 申明一个原子性变量

void func()
{
    for (int i = 0; i < 1000000; ++i) {
        counter++; // 自增操作
    }
}

int main()
{
    std::thread t1(func);
    std::thread t2(func);

    t1.join();
    t2.join();

    std::cout << "counter: " << counter << std::endl;
    return 0;
}

Im obigen Code erstellen wir zwei Threads t1 und t2 und verwenden einen Zähler vom Typ std::atomic

Zusammenfassung

In diesem Artikel werden einige Multithread-Programmiertechniken in C++ vorgestellt. Die Verwendung von Mutex-Sperren und Bedingungsvariablen kann gemeinsam genutzte Ressourcen schützen und die Thread-Kommunikation implementieren, während die Verwendung von std::atomic atomare Operationen garantieren und Probleme im Zusammenhang mit Multithreading vermeiden kann. Achten Sie bei der Verwendung von Multithread-Programmierung bitte auf Thread-Sicherheit und -Korrektheit und stellen Sie sicher, dass Vorgänge auf gemeinsam genutzten Ressourcen atomar sind.

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