Parallele Berechnungen mit Threads: Zahlen aus einem Array summieren

Parallele Berechnungen mit Threads: Zahlen aus einem Array summieren

Inhaltsverzeichnis:

1. Einführung
2. Grundlagen des Argumentübertragsens an Threads
3. Ein einfaches Beispiel 3.1. Die Aufgabe des Programms 3.2. Implementierung des Programms
4. Anpassung der Anzahl der Threads
5. Implementierung der Summierung der Zahlen 5.1. Verwendung einer Schleife 5.2. Berücksichtigung des Index
6. Rückgabe des Teilergebnisses 6.1. Speicherplatz reservieren und zurückgeben 6.2. Verwendung der zurückgegebenen Werte
7. Berechnung der Gesamtsumme 7.1. Verwendung einer globalen Variablen 7.2. Freigabe des Speicherplatzes
8. Alternative Implementierungsmöglichkeiten
9. Zusammenfassung und Fazit

\ud83d\udea9 Ein einfaches Beispiel

Um die Konzepte des Argumentübertragsens an Threads zu veranschaulichen, möchten wir ein einfaches Beispiel betrachten. Anstatt zehn Threads zu verwenden, beschränken wir uns auf nur zwei Threads. Unser Ziel ist es, die Summe aller Zahlen in einem Array zu berechnen. Dazu teilen wir das Array in zwei Hälften auf. Die erste Hälfte wird dem ersten Thread übergeben, während die zweite Hälfte dem zweiten Thread übergeben wird. Anschließend erhalten wir von jedem Thread eine Teilsumme und addieren diese in unserem Hauptthread zusammen, um das Endergebnis zu erhalten.

Einführung

Das Argumentübertragen an Threads ist eine wichtige Konzeption in der Programmierung. Es ermöglicht uns, Daten zwischen Threads auszutauschen und parallele Berechnungen durchzuführen. In diesem Artikel werden wir uns mit einem einfachen Beispiel befassen, um die Grundlagen des Argumentübertragens an Threads zu verstehen. Wir werden die Implementierung Schritt für Schritt durchgehen und alle Konzepte erklären.

Grundlagen des Argumentübertragsens an Threads

Bevor wir uns das praktische Beispiel anschauen, lohnt es sich, die Grundlagen des Argumentübertragens an Threads zu verstehen. Wenn wir einen Thread starten, können wir ihm optional ein Argument übergeben. Das Argument kann eine beliebige Datenstruktur sein, wie zum Beispiel eine Zahl, ein Array oder ein Objekt. Das übergebene Argument wird dann vom Thread verwendet, um seine Aufgabe auszuführen.

Ein einfaches Beispiel

3.1. Die Aufgabe des Programms

In unserem Beispiel möchten wir die Summe aller Zahlen in einem Array berechnen. Das Array besteht aus Primzahlen und hat eine feste Größe. Wir möchten den Berechnungsprozess parallelisieren, um die Ausführungszeit zu verkürzen. Dazu verwenden wir zwei Threads, um das Array in zwei Hälften aufzuteilen und die Teilsummen zu berechnen. Abschließend addieren wir die Teilsummen zusammen, um die Gesamtsumme zu erhalten.

3.2. Implementierung des Programms

Um das Programm umzusetzen, müssen wir zunächst die Anzahl der Threads ändern. In unserem Fall verwenden wir nur zwei Threads. Wir initialisieren einen Zähler "i" von null bis einschließlich eins und verwenden ihn, um den Startindex für die jeweilige Hälfte des Arrays zu berechnen. Für den ersten Thread übergeben wir den Startindex null, für den zweiten Thread übergeben wir den Startindex fünf. Auf diese Weise werden nur die entsprechenden Zahlen in jeder Teilhälfte des Arrays summiert.

Anpassung der Anzahl der Threads

Um die Anzahl der Threads anzupassen, ändern wir den Zählbereich des Zählers "i". In unserem Beispiel verwenden wir nur zwei Threads, daher setzen wir den Zählbereich von null bis einschließlich eins. Wenn Sie mehr Threads verwenden möchten, können Sie den Zählbereich entsprechend anpassen.

Implementierung der Summierung der Zahlen

Um die Zahlen in den Teilhälften des Arrays zu summieren, verwenden wir eine Schleife. In unserem Beispiel verwenden wir eine for-Schleife von null bis einschließlich vier, da wir fünf Zahlen in jeder Teilhälfte haben. Wir initialisieren eine Summierungsvariable "sum" mit null und addieren in jedem Schleifendurchlauf das entsprechende Arrayelement dazu.

Verwendung einer Schleife

Eine Schleife ist eine effektive Möglichkeit, um wiederholte Berechnungen durchzuführen. In unserem Fall verwenden wir eine for-Schleife, da wir die Zahlen in den Teilhälften des Arrays nacheinander summieren möchten. Alternativ könnten wir auch eine while-Schleife verwenden, je nachdem, welches Format für Ihren Code besser geeignet ist.

Berücksichtigung des Index

Um sicherzustellen, dass wir die richtigen Zahlen in jeder Teilhälfte des Arrays summieren, müssen wir den Index berücksichtigen. In unserem Fall verwenden wir den Zähler "i" und multiplizieren ihn mit fünf, um den Startindex für jede Teilhälfte zu erhalten. Auf diese Weise summieren wir nur die entsprechenden Zahlen und erhalten das korrekte Ergebnis.

Rückgabe des Teilergebnisses

Nachdem wir die Teilsummen in den Threads berechnet haben, müssen wir sie zurückgeben, um sie im Hauptthread zu verwenden. Es gibt verschiedene Möglichkeiten, dies zu tun. In unserem Fall haben wir uns für die Rückgabe über den Funktionsergebnis entschieden. Wir speichern die Teilsumme in einer dynamisch allokierten Variable und geben diese zurück. Der Hauptthread verwendet dann diese Rückgabewerte, um die Gesamtsumme zu berechnen.

Speicherplatz reservieren und zurückgeben

Um Speicherplatz für die Teilsumme zu reservieren, verwenden wir die Funktion "malloc" oder "calloc" in C. Dadurch wird Speicherplatz im Heap allokiert und kann von allen Threads verwendet werden. Nachdem wir den Speicherplatz reserviert haben, geben wir die Adresse des reservierten Speicherbereichs als Rückgabewert zurück. Der Hauptthread verwendet diese Adresse, um auf die Teilsumme zuzugreifen und sie in die Gesamtsumme einzubeziehen.

Verwendung der zurückgegebenen Werte

Um die zurückgegebenen Werte zu verwenden, speichern wir sie in einer Variable und addieren sie zur globalen Summe hinzu. Die globale Summe ist eine Variable, die im Hauptthread deklariert und initialisiert wird. Sie speichert die endgültige Gesamtsumme, die aus den Teilsummen der Threads berechnet wird. Nachdem wir die Teilsummen zur globalen Summe hinzugefügt haben, können wir den reservierten Speicherplatz freigeben, um Speicherlecks zu vermeiden.

Berechnung der Gesamtsumme

Um die Gesamtsumme zu berechnen, verwenden wir eine globale Variable, um die Teilsummen der Threads zu speichern. Diese Variable wird im Hauptthread deklariert und initialisiert. Nachdem wir die Teilsummen erhalten haben, addieren wir sie zur globalen Summe hinzu und erhalten die endgültige Gesamtsumme des Arrays. Beachten Sie, dass die globale Variable gemeinsam von allen Threads verwendet wird und daher adäquate Synchronisierung erforderlich ist.

Freigabe des Speicherplatzes

Nachdem wir die Teilsummen zur globalen Summe hinzugefügt haben, müssen wir den reservierten Speicherplatz freigeben, um Speicherlecks zu vermeiden. Für jede dynamisch allokierte Variable sollten wir eine entsprechende Freigabefunktion verwenden, wie z.B. "free" in C. Durch die Freigabe des Speicherplatzes stellen wir sicher, dass keine ungenutzten Speicherbereiche belegt bleiben und es zu keinen Ressourcenproblemen kommt.

Alternative Implementierungsmöglichkeiten

Es gibt verschiedene Möglichkeiten, das oben beschriebene Beispiel zu implementieren. Anstatt die Teilsummen zurückzugeben, könnten wir sie auch direkt in den Threads summieren und eine globale Variable als Zwischenspeicher verwenden. Diese Implementierung erfordert jedoch eine geeignete Synchronisierung, um Rennbedingungen zu vermeiden. Beide Ansätze haben Vor- und Nachteile und können je nach Anforderungen und Präferenzen gewählt werden.

Zusammenfassung und Fazit

In diesem Artikel haben wir die Grundlagen des Argumentübertragsens an Threads behandelt und ein einfaches Beispiel zur Veranschaulichung gegeben. Wir haben verschiedene Schritte erklärt, von der Anpassung der Anzahl der Threads bis zur Berechnung der Gesamtsumme. Es gibt noch viele weitere Aspekte des Threadings zu entdecken, aber dieses Beispiel sollte Ihnen einen guten Einstieg bieten. Wir hoffen, dass dieser Artikel hilfreich war und freuen uns über Ihr Feedback und Ihre Fragen.

Highlights:

• Einführung in Argumentübertragung an Threads
• Implementierung eines einfachen Beispiels zur Summierung von Zahlen in einem Array
• Anpassung der Anzahl der Threads für parallele Berechnungen
• Verwendung einer Schleife zur Berechnung der Teilsummen
• Rückgabe der Teilsummen und Berechnung der Gesamtsumme
• Alternative Implementierungsmöglichkeiten beachten
• Zusammenfassung und Fazit des Beispiels

FAQ:

• Was ist die Argumentübertragung an Threads? Die Argumentübertragung an Threads ermöglicht es, Daten zwischen parallel laufenden Threads auszutauschen, um parallele Berechnungen durchzuführen.

• Wie kann ich die Anzahl der Threads anpassen? Du kannst die Anzahl der Threads in deinem Programm ändern, indem du den Zählbereich des Zählers anpasst oder die entsprechenden Threads erstellst.

• Welche Rolle spielt der Index in der Berechnung der Teilsummen? Der Index wird verwendet, um den Startpunkt für die Berechnung der Teilsummen festzulegen. Durch die Verwendung des Index können wir die Zahlen in den Teilhälften des Arrays korrekt summieren.

• Was ist die beste Methode, um die Teilsummen zurückzugeben? Die beste Methode, um die Teilsummen zurückzugeben, hängt von den Anforderungen und Präferenzen ab. Eine Möglichkeit ist die Verwendung einer dynamisch allokierten Variable, die über den Funktionsrückgabewert zurückgegeben wird.

• Wie kann ich die Gesamtsumme berechnen? Die Gesamtsumme kann berechnet werden, indem die Teilsummen miteinander addiert werden. Dies kann in einer globalen Variablen gespeichert werden, die von allen Threads gemeinsam verwendet wird.

• Gibt es alternative Implementierungsmöglichkeiten für dieses Beispiel? Ja, es gibt alternative Implementierungsmöglichkeiten. Anstatt die Teilsummen zurückzugeben, könnten wir sie direkt in den Threads summieren und eine globale Variable als Zwischenspeicher verwenden. Dies erfordert jedoch eine geeignete Synchronisierung.

Ressourcen:

• Beispielcode auf unserer Website