# Aufgabe

Stellen Sie sich vor, Sie haben eine **Liste von Dateien**, von denen jede Zeilen mit Text enthält. Ihre Aufgabe ist es, diese Zeilen **parallel** zu **lesen** und die **Anzahl der Wörter** in jeder Zeile zu zählen. Verwenden Sie `ExecutorService`, `Future` und einen **Thread-Pool**, um die Aufgabe zu erledigen.

## Anforderungen:
- **Erstellen Sie einen Thread-Pool**: Erstellen Sie einen Thread-Pool fester Größe mit `Executors.newFixedThreadPool(int nThreads)`, wobei `nThreads` die Anzahl der Threads im Pool ist;

- **Aufgabenimplementierung**: Implementieren Sie eine `WordCountTask`-Klasse, die das `Callable<String>`-Interface implementiert und eine Datei als Eingabe erhält. In der **call**-Methode dieser Klasse **lesen** Sie Zeilen aus der Datei, zählen die Anzahl der Wörter in jeder Zeile und geben das Ergebnis zurück;

- **Verwendung von** `ExecutorService`: Verwenden Sie `ExecutorService`, um Jobs zur Ausführung an den Thread-Pool zu senden. Die Jobs müssen die `WordCountTask`-Klasse verwenden.

>Hinweis
>
> Auch der String, den Sie in einem separaten Thread bilden, muss zurückgegeben werden, und Sie müssen die `get()`-Methode des `Future`-Interfaces verwenden, um das Ergebnis der Thread-Ausführung zu erhalten und in der **main-Methode** auszugeben.

### Aus Datei lesen
Um die `call()` **Methode** zu implementieren, können Sie `BufferedReader` verwenden, um Zeichenfolgen aus **Dateien** zu lesen. Verwenden Sie einen `try-with-resources` **Block**, damit Ressourcen automatisch für Sie **geschlossen** werden.



QnVmZmVyZWRSZWFkZXIgcmVhZGVyID0gbmV3IEJ1ZmZlcmVkUmVhZGVyKG5ldyBGaWxlUmVhZGVyKGZpbGUpKTs=

Verwenden Sie die `readLine()` **Methode**, um jede Zeile zu lesen, und achten Sie darauf, `null` zu überprüfen, um festzustellen, wann Sie das Ende der **Datei** erreicht haben.

Teilen Sie als Nächstes **die Zeichenkette** in ein Array von Zeichenketten auf, indem Sie die `split("\\s+")` **Methode** mit dem `\\s+` **Muster** verwenden, das die Zeichenkette durch Leerzeichen trennt, und ermitteln Sie dann die **Größe** des Arrays.

Verwenden Sie in der Zeichenkette selbst, die der Stream zurückgibt, **dieses Format**

U3RyaW5nLmZvcm1hdCgiRmlsZTogJXMgfCBMaW5lOiAlcyB8IFdvcmQgQ291bnQgJWQiLCBmaWxlTmFtZSwgbGluZSwgY291bnRXb3JkKQ==

****Dateien sind bereits im Projekt, Sie müssen sie nicht erstellen oder ändern!****


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

Herausforderung Executors

Aufgabe

Anforderungen:

Aus Datei lesen

Beispielausgabe