C Multithreading und Parallelität: Parallele Programmierung beherrschen

C Die Kernkonzepte von Multithreading und gleichzeitiger Programmierung umfassen Thread -Erstellung und -management, Synchronisation und gegenseitige Ausschluss, bedingte Variablen, Thread -Pooling, asynchrones Programmieren, gemeinsame Fehler und Debugging -Techniken sowie Leistungsoptimierung sowie Best Practices. 1) Erstellen Sie Threads mit der STD :: Thread -Klasse. Das Beispiel zeigt, wie der Thread erstellt und wartet. 2) Synchronisieren und gegenseitige Ausschluss, um std :: mutex und std :: lock_guard zu verwenden, um gemeinsam genutzte Ressourcen zu schützen und den Datenwettbewerb zu vermeiden. 3) Zustandsvariablen realisieren Kommunikation und Synchronisation zwischen Threads über std :: Condition_Variable. 4) Das Beispiel des Thread -Pools zeigt, wie die Threadpool -Klasse verwendet wird, um Aufgaben parallel zu verarbeiten, um die Effizienz zu verbessern. 5) Asynchrone Programmierung wird mit STD :: Async und Std :: Future implementiert. Das Beispiel zeigt den Start- und Ergebniserwerb von asynchronen Aufgaben. 6) Zu den häufigen Fehlern gehören Datenwettbewerb, Deadlocks und Ressourcenleckage, Debugging -Fähigkeiten umfassen die Verwendung von Schlössern und Atomoperationen sowie Debugging -Tools. 7) Vorschläge zur Leistungsoptimierung umfassen die Verwendung von Threadpools, STD :: Atomic und angemessene Verwendung von Schlössern, um die Programmleistung und -sicherheit zu verbessern.

Einführung

In der modernen Programmierung sind Multithreading und gleichzeitige Programmierung zu einer Schlüsseltechnologie zur Verbesserung der Programmleistung und -reaktionsfähigkeit geworden. Unabhängig davon, ob Sie leistungsstarke Computeranwendungen entwickeln oder eine reaktionsschnelle Benutzeroberfläche erstellen, Multi-Threading und gleichzeitige Programmierung in C beherrschen, ist eine wesentliche Fähigkeit. In diesem Artikel werden Sie in das tiefe Verständnis der Kernkonzepte und praktischen Techniken von C -Multithreading und gleichzeitiger Programmierung aufgenommen und Ihnen helfen, ein Meister der parallelen Programmierung zu werden.

Durch das Lesen dieses Artikels lernen Sie, wie Sie Threads erstellen und verwalten, die Synchronisations- und gegenseitige Ausschlussmechanismen in der gleichzeitigen Programmierung verstehen und wie häufig gleichzeitige Programmierstoffe vermieden werden. Egal, ob Sie ein Anfänger oder ein erfahrener Entwickler sind, Sie können davon profitieren.

Überprüfung des Grundwissens

Bevor wir in C -Multithreading und gleichzeitige Programmierung eintauchen, lesen wir zuerst einige Grundlagen. Der C 11 -Standard führt die <thread></thread> -Bibliothek ein und erstellt und verwaltet Threads in C einfacher und intuitiver. Darüber hinaus bieten Bibliotheken wie <mutex></mutex> , <condition_variable></condition_variable> und <atomic></atomic> die erforderlichen Tools, um die Synchronisation und Kommunikation zwischen Threads zu verarbeiten.

Das Verständnis dieser grundlegenden Konzepte ist entscheidend für die Beherrschung von Multi-Thread-Programmen. Beispielsweise sind Threads die kleinste Einheit der Betriebssystemplanung, während Mutexes zum Schutz der gemeinsamen Ressourcen und zur Verhütung des Datenwettbewerbs verwendet werden.

Kernkonzept oder Funktionsanalyse

Erstellung und Verwaltung von Faden

In C ist das Erstellen eines Threads sehr einfach. Verwenden Sie einfach std::thread -Klasse. Hier ist ein einfaches Beispiel:

 #include <iostream>
#include <Thread>

void thread_function () {
    std :: cout << "Hallo aus Thread!" << std :: endl;
}

int main () {
    std :: thread t (thread_function);
    T.Join ();
    Rückkehr 0;
}

In diesem Beispiel wird angezeigt, wie Sie einen Thread erstellen und darauf warten, dass er abgeschlossen ist. join() blockiert den Haupt -Thread, bis der untergeordnete Thread die Ausführung abschließt.

Synchronisation und gegenseitiger Ausschluss

Bei der Multithread -Programmierung sind Synchronisation und gegenseitige Ausschluss der Schlüssel zur Vermeidung von Datenwettbewerb. std::mutex und std::lock_guard sind häufig verwendete Werkzeuge. Hier ist ein Beispiel für die Verwendung von Mutex zum Schutz der gemeinsamen Ressourcen:

 #include <iostream>
#include <Thread>
#Include <Mutex>

std :: mutex mtx;
int Shared_data = 0;

void Increment () {
    für (int i = 0; i <100000; i) {
        std :: lock_guard <std :: mutex> lock (MTX);
          Shared_data;
    }
}

int main () {
    std :: Thread T1 (Inkrement);
    std :: Thread T2 (Inkrement);
    t1.join ();
    t2.join ();
    std :: cout << "endgültiger Wert von Shared_data:" << Shared_data << std :: endl;
    Rückkehr 0;
}

In diesem Beispiel stellt std::lock_guard sicher, dass der Mutex beim Zugriff auf shared_data ordnungsgemäß gesperrt und entsperrt ist, wodurch der Datenwettbewerb vermieden wird.

Bedingte Variablen

Zustandsvariablen sind ein weiterer wichtiger Synchronisationsmechanismus, der für die Kommunikation zwischen Threads verwendet wird. Hier ist ein Beispiel für die Verwendung von bedingten Variablen:

 #include <iostream>
#include <Thread>
#Include <Mutex>
#include <condition_variable>

std :: mutex mtx;
std :: Condition_Variable CV;
bool bereit = falsch;

void print_id (int id) {
    std :: Unique_lock <std :: mutex> lck (MTX);
    while (! bereit) cv.wait (LCK);
    std :: cout << "Thread" << id << std :: endl;
}

void go () {
    std :: Unique_lock <std :: mutex> lck (MTX);
    bereit = wahr;
    cv.notify_all ();
}

int main () {
    std :: Thread -Threads [10];
    für (int i = 0; i <10; i) {
        Threads [i] = std :: thread (print_id, i);
    }
    std :: cout << "10 Threads bereit zum Rennen ..." << std :: endl;
    gehen();
    für (auto & th: threads) th.join ();
    Rückkehr 0;
}

In diesem Beispiel wird der cv der Bedingungsvariablen verwendet, um alle wartenden Threads zur Startausführung zu benachrichtigen.

Beispiel für die Nutzung

Grundnutzung

Das Erstellen und Verwalten von Threads ist die Grundlage für die Multi-Thread-Programmierung. Hier ist ein komplexeres Beispiel, das zeigt, wie Threadpools parallel zum Verarbeiten von Aufgaben verwendet werden:

 #include <iostream>
#include <Vector>
#include <Thread>
#include <queue>
#Include <Mutex>
#include <condition_variable>
#Include <funktion>

Klasse Threadpool {
öffentlich:
    Threadpool (size_t threads): stop (false) {
        für (size_t i = 0; i <threads; i) {
            Workers.emplace_back ([this] {
                while (wahr) {
                    std :: function <void ()> Aufgabe;
                    {
                        STD :: einzigartig_lock <std :: mutex> lock (queue_mutex);
                        condition.wait (lock, [this] {return stop ||! tasks.eMpty ();});
                        if (stop && tasks.empty ()) return;
                        task = std :: move (tasks.front ());
                        tasks.pop ();
                    }
                    Aufgabe();
                }
            });
        }
    }

    Vorlage <Klasse F, Klasse ... args>
    Auto Enqueue (F && f, Args && ... Args) 
        -> std :: Future <Typename std :: result_of <f (args ...)> :: type>
    {
        Verwenden von return_type = typeName std :: result_of <f (args ...)> :: type;

        auto task = std :: make_shared <std :: packaged_task <return_type () >> (
            std :: bind (std :: vorne <f> (f), std :: vorwärts <args> (args) ...)
        );

        std :: Future <Return_type> res = task-> get_future ();
        {
            STD :: einzigartig_lock <std :: mutex> lock (queue_mutex);
            if (Stopp) sterieren std :: runtime_error ("Enqueue on Stop -threadpool");
            tasks.emPlace ([task] () {(*task) ();});
        }
        condition.notify_one ();
        return res;
    }

    ~ Threadpool () {
        {
            STD :: einzigartig_lock <std :: mutex> lock (queue_mutex);
            stop = true;
        }
        condition.notify_all ();
        für (std :: thread & Worker: Arbeiter) Worker.join ();
    }

Privat:
    std :: vector <std :: thread> Arbeiter;
    std :: queue <std :: function <void () >> Aufgaben;

    std :: mutex queue_mutex;
    std :: Condition_variable Bedingung;
    Bool Stopp;
};

int main () {
    Threadpool -Pool (4);
    std :: vector <std :: Future <int >> Ergebnisse;

    für (int i = 0; i <8; i) {
        results.emplace_back (
            pool.enqueue ([i] {
                kehre ich * i;
            })
        );
    }

    für (Auto && Ergebnis: Ergebnisse) {
        std :: cout << result.get () << &#39;&#39;;
    }
    std :: cout << std :: endl;

    Rückkehr 0;
}

Dieses Beispiel zeigt, wie Thread -Pools verwendet werden, um Aufgaben parallel zu verarbeiten und die Programme und Effizienz zu verbessern.

Erweiterte Verwendung

In praktischen Anwendungen können komplexere gleichzeitige Programmierszenarien auftreten. Verwenden Sie beispielsweise std::async und std::future , um eine asynchrone Programmierung zu implementieren:

 #include <iostream>
#Include <Future>
#Include <HRONO>

int main () {
    auto future = std :: async (std :: start :: async, [] {{
        std :: this_thread :: sleep_for (std :: chrono :: Sekunden (2));
        Rückkehr 42;
    });

    std :: cout << "Warten auf Ergebnis ..." << std :: endl;
    int result = future.get ();
    std :: cout << "Ergebnis:" << Ergebnis << std :: endl;

    Rückkehr 0;
}

In diesem Beispiel wird std::async verwendet, um eine asynchrone Aufgabe zu beginnen, std::future wird verwendet, um die Ergebnisse der Aufgabe zu erhalten.

Häufige Fehler und Debugging -Tipps

Häufige Fehler in der Multithread -Programmierung umfassen Datenrennen, Deadlocks und Ressourcenleckage. Hier sind einige Debugging -Tipps:

• Verwenden Sie std::lock_guard und std::unique_lock um die korrekte Verwendung von Mutexes zu gewährleisten und Deadlocks zu vermeiden.
• Verwenden Sie std::atomic , um gemeinsam genutzte Variablen zu verarbeiten und den Datenwettbewerb zu vermeiden.
• Verwenden Sie Debugging -Tools wie Valgrind oder Addressanitizer, um Speicherlecks und Datenwettbewerb zu erkennen.

Leistungsoptimierung und Best Practices

In praktischen Anwendungen ist es wichtig, die Leistung von Multi-Thread-Programmen zu optimieren. Hier finden Sie einige Optimierungs -Tipps und Best Practices:

• Vermeiden Sie eine übermäßige Erstellung und Zerstörung von Fäden und verwenden Sie Thread -Pools, um Threads zu verwalten.
• Verwenden Sie std::atomic , um die Zugangseffizienz von gemeinsam genutzten Variablen zu verbessern.
• Verwenden Sie Schlösser vernünftigerweise, um die Granularität von Schlössern zu verringern und die Konkurrenz zu vermeiden.

Beispielsweise finden Sie hier ein Beispiel für die Verwendung von std::atomic , um den Zugriff auf gemeinsame Variablen zu optimieren:

 #include <iostream>
#include <Thread>
#include <atomic>

std :: atomic <int> shared_data (0);

void Increment () {
    für (int i = 0; i <100000; i) {
          Shared_data;
    }
}

int main () {
    std :: Thread T1 (Inkrement);
    std :: Thread T2 (Inkrement);
    t1.join ();
    t2.join ();
    std :: cout << "endgültiger Wert von Shared_data:" << Shared_data << std :: endl;
    Rückkehr 0;
}

In diesem Beispiel verbessert die Verwendung von std::atomic um den atomarischen Betrieb gemeinsamer Variablen zu gewährleisten, die Programmleistung und -sicherheit.

Kurz gesagt, C -Multithreading und gleichzeitige Programmierung sind eine komplexe, aber sehr nützliche Technik. Durch die Untersuchung dieses Artikels sollten Sie die Kernkonzepte und -Techniken wie das Erstellen und Verwalten von Threads, die Synchronisation und die gegenseitige Ausschluss sowie die Leistungsoptimierung beherrschen. Ich hoffe, dieses Wissen kann Ihnen helfen, die Programmierung von Multi-Thread-Programmen in realen Projekten besser anzuwenden und die Programmleistung und -reaktionsfähigkeit zu verbessern.

Das obige ist der detaillierte Inhalt vonC Multithreading und Parallelität: Parallele Programmierung beherrschen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!