# Aufgabe

Sie müssen eine Logik schreiben, um **100 Threads** zu erstellen, von denen jeder **die Fakultät des Indexes** in einer Schleife berechnet und das Ergebnis im `results`-Array speichert.
Sie müssen auch **warten**, bis alle Threads abgeschlossen sind, bevor Sie die Ergebnisse ausgeben. **(`join()` Methode)**

Die Methoden `factorial()`, `printMassive()`, `getResults()` sind fertig und Sie müssen sie in keiner Weise ändern

`factorial(Integer)` - berechnet die Fakultät der übergebenen Zahl;

`printMassive(BigInteger[])` - gibt das Ergebnisse-Array auf der Konsole aus;

`getResults()` - gibt das Ergebnisse-Array zurück (wird für Tests verwendet);

`SIZE_MASSIVE` - Konstante zur Definition des Array-Werts (NICHT ÄNDERN);

`results[]` - Array zur Aufzeichnung der Ergebnisse.

Sobald Sie die Aufgabe erledigt haben, gehen Sie zu `src/test/java/TaskThreadTest.java` und führen Sie sie aus

Sie sollten nur **einen Test** haben, um ihn beim ersten Mal zu bestehen

Wenn Sie die Aufgabe korrekt ausführen, sollten alle Tests bestehen. Wenn ein Test nicht besteht, haben Sie `calculateFactorialsInParallel()` falsch implementiert oder jene **Felder/Methoden** geändert, die nicht geändert werden dürfen.

# Implementierungsplan


1. **Erstellen Sie ein Array von Threads**: Richten Sie ein Array von `Thread`-**Objekten** ein, wobei jedes Element einem **anderen Thread** entspricht. Die **Größe** des Arrays sollte mit dem Array übereinstimmen, das Sie verarbeiten (`SIZE_MASSIVE = 100`).

2. **Initialisieren Sie jeden Thread**: In einer **Schleife**, die durch jedes Element des Arrays iteriert, erstellen Sie einen neuen **Thread**. Innerhalb dieses Threads führen Sie die erforderliche **Aufgabe** aus (berechnen Sie die Fakultät des Indexes). Speichern Sie das Ergebnis im **Ergebnisarray**.

3. **Starten Sie die Threads**: Sobald jeder **Thread** erstellt ist, starten Sie ihn, indem Sie die `start()`-Methode aufrufen.

4. **Warten Sie, bis alle Threads abgeschlossen sind**: Nachdem alle Threads gestartet wurden, verwenden Sie die `join()`-**Methode** für jeden Thread, um sicherzustellen, dass der Hauptprogramm-Thread **wartet**, bis **alle Threads beendet sind**. Dies garantiert, dass alle **Berechnungen** abgeschlossen sind, bevor der **Hauptprogramm-Thread** fortfährt.

Dieser Kurs ist für diejenigen gedacht, die ihr Wissen über Multithreading erweitern und dessen Fähigkeiten nutzen möchten, um effiziente, leistungsstarke Anwendungen zu erstellen. Sie werden in wesentliche Konzepte, praktische Techniken und bewährte Verfahren im Multithreading eintauchen, die Sie befähigen, komplexe Probleme der Nebenläufigkeit sicher anzugehen.

Dieser Abschnitt behandelt die grundlegenden Konzepte der Multithread-Verarbeitung in Java, mit Schwerpunkt auf der Erstellung und Verwaltung von Threads sowie der Verwendung von Synchronisationstechniken zur Vermeidung von Konflikten. Sie lernen auch, wie Sie wesentliche Keywords und Methoden nutzen, um die genaue und zuverlässige Ausführung von Multithread-Programmen sicherzustellen, und erhalten ein solides Verständnis dafür, wie Sie die Parallelität in Ihren Anwendungen effektiv handhaben können.

Dieser Abschnitt untersucht synchronisierte Sammlungen in Java, erklärt ihren Zweck und die häufigen Nebenläufigkeitsprobleme, die sie lösen sollen. Sie erhalten Einblicke, wie diese Sammlungen funktionieren, warum sie in multithreaded Umgebungen unerlässlich sind und wie sie helfen, eine sichere und konsistente Datenmanipulation zu gewährleisten, wenn mehrere Threads auf gemeinsame Ressourcen zugreifen.

Dieser Abschnitt behandelt hochrangige Synchronisationsmechanismen in Java, wie die Verwendung von Lock und Condition, Semaphoren, Barrieren, atomaren Variablen und Thread-Pooling mit Executors. Jedes Thema ist mit praktischen Übungen gekoppelt, die Ihr Verständnis vertiefen und Ihnen helfen sollen, das theoretische Wissen auf reale Szenarien anzuwenden.

Dieser Abschnitt untersucht grundlegende Muster und Praktiken der Multithread-Programmierung wie Producer-Consumer, Fork/Join, ThreadLocal und asynchrone Programmierung mit CompletableFuture. Sie werden Beispiele durchgehen und die praktischen Ergebnisse dieser Ansätze sehen, wobei Sie praktische Erfahrungen sammeln, die es Ihnen ermöglichen, diese Techniken effektiv in realen Anwendungen anzuwenden.

Multithreading in Java

Multithreading-Aufgabe

Aufgabe

Implementierungsplan