Das Schlüsselkonzept der C++-Multithread-Programmierung ist, wie Threads synchronisiert werden.

C++-Multithread-Synchronisationsschlüsselkonzepte: Mutex-Sperre: Stellen Sie sicher, dass nur ein Thread auf den kritischen Abschnitt zugreifen kann. Bedingungsvariablen: Threads können aktiviert werden, wenn bestimmte Bedingungen erfüllt sind. Atomare Operation: Eine unterbrechungsfreie Einzel-CPU-Anweisung, um die Atomizität gemeinsam genutzter Variablenänderungen sicherzustellen.

Schlüsselkonzepte der C++-Multithread-Programmierung: Thread-Synchronisierung

Thread-Synchronisierung ist ein entscheidender Bestandteil der Multithread-Programmierung. Sie stellt sicher, dass mehrere Threads sicher auf gemeinsam genutzte Ressourcen zugreifen und Konflikte und Datenbeschädigungen vermeiden können. Im Folgenden werden die Schlüsselkonzepte der Thread-Synchronisation in C++ vorgestellt:

Mutex:

Mutex (Mutex) ist ein Zugriffskontrollmechanismus, der jeweils nur einem Thread den Zugriff auf den kritischen Abschnitt ermöglicht, d. h. synchroner Zugriff ist erforderlich Codebereich. Durch die Verwendung einer Mutex-Sperre kann verhindert werden, dass mehrere Threads gemeinsam genutzte Variablen gleichzeitig ändern, was zu Datenbeschädigungen führt.

std::mutex mtx;  // 定义互斥锁对象

void someFunction() {
    std::lock_guard<std::mutex> lock(mtx);  // 在进入临界区前加锁
    // 访问临界区代码
}

Bedingte Variablen:

Bedingte Variablen ermöglichen das Aufwecken von Threads, wenn bestimmte Bedingungen erfüllt sind. Dies ist bei der kooperativen Multithread-Programmierung nützlich, beispielsweise wenn ein Thread darauf wartet, dass ein anderer Thread Daten produziert.

std::condition_variable cv;  // 定义条件变量对象
std::mutex mtx;  // 关联的互斥锁对象

void produce() {
    std::lock_guard<std::mutex> lock(mtx);  // 加锁
    // 产生数据
    cv.notify_all();  // 通知所有等待此条件的线程
}

void consume() {
    std::unique_lock<std::mutex> lock(mtx);  // 加锁
    cv.wait(lock);  // 等待 `produce()` 函数生产数据
    // 消费数据
}

Atomere Operationen:

Atomere Operationen sind einzelne CPU-Anweisungen, die nicht von anderen Threads unterbrochen werden können, wodurch sichergestellt wird, dass Änderungen an gemeinsam genutzten Variablen atomar sind.

std::atomic<int> count;  // 定义原子变量

void incrementCount() {
    count++;  // 原子方式增加 `count`
}

Praktischer Fall:

Betrachten Sie das folgende Multithread-Programm:

std::vector<int> numbers;  // 共享的整型数组

void addNumber(int n) {
    numbers.push_back(n);
}

int main() {
    std::thread t1(addNumber, 1);
    std::thread t2(addNumber, 2);
    t1.join();
    t2.join();
    
    std::cout << "Numbers in the vector: ";
    for (int n : numbers) {
        std::cout << n << " ";
    }
    std::cout << std::endl;
    
    return 0;
}

In diesem Beispiel numbers ist das Array eine gemeinsam genutzte Ressource, auf die mehrere Threads gleichzeitig zugreifen können. Wenn keine Synchronisierungsmaßnahmen ergriffen werden, kann es zu Race Conditions kommen, die zu Datenbeschädigungen führen.

Um sicher auf das Array zuzugreifen, können wir eine Mutex-Sperre verwenden:

void addNumber(int n) {
    std::lock_guard<std::mutex> lock(mtx);  // 在访问数组前加锁
    numbers.push_back(n);
}

Auf diese Weise kann jeweils nur ein Thread auf das Array zugreifen, wodurch die Datenintegrität gewährleistet wird.

Ausgabe:

Numbers in the vector: 1 2 

Das obige ist der detaillierte Inhalt vonDas Schlüsselkonzept der C++-Multithread-Programmierung ist, wie Threads synchronisiert werden.. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!