Implementieren Sie Thread-Programmierung mit C++

Mit der kontinuierlichen Weiterentwicklung der Computertechnologie sind Multi-Core-Prozessoren und Multi-Thread-Programmierung zu immer wichtigeren und verbreiteten Technologien geworden. Als weit verbreitete objektorientierte Programmiersprache bietet C++ einzigartige Vorteile bei der Realisierung von Multithread-Programmierung. In diesem Artikel wird erläutert, wie Sie mit C++ die Thread-Programmierung implementieren, einschließlich Thread-Erstellung, Synchronisierung und gegenseitigem Ausschluss.

1. Das Grundkonzept von Threads

Threads sind die grundlegenden Ausführungseinheiten von Prozessen. Ein Prozess kann mehrere Threads enthalten. Threads haben die folgenden Eigenschaften:

(1) Threads sind Teil des Prozesses und teilen sich daher den Speicherplatz des Prozesses.

(2) Threads können gleichzeitig ausgeführt werden, was die Laufeffizienz des Programms verbessert.

(3) Daten können zwischen Threads geteilt werden, es gibt jedoch auch Probleme mit der Datenkonkurrenz.

(4) Threads haben unabhängige Ausführungsprozesse und können ihre eigenen Stapel und Register usw. haben.

2. Erstellung von Threads

C++ bietet eine Vielzahl von Methoden zum Erstellen von Threads, von denen die Verwendung der Thread-Klasse am häufigsten verwendet wird.

(1) Erstellen Sie ein Thread-Objekt

Verwenden Sie den Konstruktor der Thread-Klasse, um ein Thread-Objekt zu erstellen, z. B. den folgenden Code:

#include <iostream>
#include <thread>

void func()
{
    std::cout << "hello from thread" << std::endl;
}

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

Im obigen Code ist die Funktion func die Ausführungsfunktion des Threads std::thread t(func) Erstellen Sie ein Thread-Objekt, rufen Sie t.join() in der Hauptfunktion auf, um den Thread auszuführen, und warten Sie, bis der Thread die Ausführung abgeschlossen hat, bevor Sie das Programm verlassen.

(2) Übergeben von Parametern

Wenn Sie Parameter im Thread übergeben müssen, können Sie die Parameter beim Erstellen des Thread-Objekts übergeben, z. B. den folgenden Code:

#include <iostream>
#include <thread>

void func(int num)
{
    std::cout << "hello from thread " << num << std::endl;
}

int main()
{
    std::thread t(func, 3);
    t.join();
    return 0;
}

Im obigen Code hat die Funktion func eine int Typparameter num, in Übergeben Sie Parameter 3 beim Erstellen des Thread-Objekts.

3. Thread-Synchronisation

Wenn mehrere Threads gleichzeitig ausgeführt werden, können einige Probleme auftreten, z. B. Datenkonkurrenz, Deadlock usw. Um diese Probleme zu vermeiden, muss das Konzept der Thread-Synchronisation eingeführt werden.

(1) Mutex

Mutex ist einer der am häufigsten verwendeten Thread-Synchronisationsmechanismen, der verhindern kann, dass mehrere Threads gleichzeitig auf gemeinsam genutzte Ressourcen zugreifen. C++ stellt die Klasse std::mutex zum Implementieren von Mutexes bereit, wie zum Beispiel den folgenden Code:

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

std::mutex mtx;

void func()
{
    mtx.lock();
    std::cout << "hello from thread" << std::endl;
    mtx.unlock();
}

int main()
{
    std::thread t(func);
    mtx.lock();
    std::cout << "hello from main" << std::endl;
    mtx.unlock();
    t.join();
    return 0;
}

Im obigen Code werden mtx.lock() und mtx.unlock() zum Sperren bzw. Entsperren des Mutex verwendet. Mutexe werden sowohl in der Funktion func als auch in der Funktion main verwendet, um die Ausgabeanweisungen zu sperren und zu entsperren, wodurch sichergestellt wird, dass die Ausgabeanweisungen in der angegebenen Reihenfolge ausgeführt werden.

(2) Bedingungsvariable

Die Bedingungsvariable ist ein Thread-Synchronisationsmechanismus, mit dem vor der Fortsetzung der Ausführung gewartet werden kann, bis eine bestimmte Bedingung erfüllt ist. C++ stellt die Klasse std::condition_variable bereit, um Bedingungsvariablen zu implementieren, wie zum Beispiel den folgenden Code:

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

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

void func1()
{
    std::unique_lock<std::mutex> ul(mtx);
    while(!flag)
    {
        cv.wait(ul);
    }
    std::cout << "hello from thread1" << std::endl;
}

void func2()
{
    std::unique_lock<std::mutex> ul(mtx);
    flag = true;
    cv.notify_one();
}

int main()
{
    std::thread t1(func1);
    std::thread t2(func2);

    t1.join();
    t2.join();
    return 0;
}

Im obigen Code wird cv.wait(ul) verwendet, um auf die Erfüllung des Bedingungsvariablen-Flags zu warten, bevor die Ausführung fortgesetzt wird, und cv.notify_one() wird verwendet, um Threads zu benachrichtigen, die auf diese Bedingungsvariable warten. Setzen Sie das Flag in der Funktion func2 auf true und benachrichtigen Sie den Thread, der auf das Zurücksetzen der Bedingungsvariablen wartet.

4. Zusammenfassung

In diesem Artikel wird erläutert, wie Sie mit C++ die Thread-Programmierung implementieren, einschließlich Thread-Erstellung, Synchronisierung und gegenseitigem Ausschluss. Durch das Studium dieses Artikels erfahren Sie, wie Sie Thread-Synchronisationsmechanismen wie Mutexe und Bedingungsvariablen verwenden, um Probleme zu vermeiden, die auftreten können, wenn mehrere Threads gleichzeitig ausgeführt werden.

Das obige ist der detaillierte Inhalt vonImplementieren Sie Thread-Programmierung mit C++. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!