# Aufgabe
Stellen Sie sich vor, Sie haben eine **Ressource**, auf die **nur zwei Threads** gleichzeitig zugreifen können. Ihre Aufgabe ist es, ein **Programm zu erstellen**, das mithilfe eines `semaphore` den **Zugriff** auf diese Ressource **steuert**.

## Bedingungen:
1. Es gibt eine **Klasse** `Resource` mit einer **Methode** `use()`, die die Nutzung einer Ressource **simuliert**, zum Beispiel durch **Ausgabe einer Nachricht** und das Einführen einer **Verzögerung**;
2. Es gibt eine **Klasse** `Worker`, die `Runnable` **implementiert**; in ihrer **Methode** `run()` versucht sie, mit einem `semaphore` auf die **Ressource** zuzugreifen;
3. In der **Klasse** `SemaphoreExample` gibt es eine **Methode** `main()`, die ein `semaphore` mit Berechtigungen für **zwei Threads** sowie mehrere Worker-**Threads** initialisiert, die versuchen, auf die Ressource zuzugreifen;
4. **Stellen Sie sicher, dass nie mehr als zwei Threads** gleichzeitig die Ressource nutzen können.

<b>Bitte nichts verändern! </b>Sie müssen nur die Methode <code>run()</code> in der Klasse <code>Worker</code> sowie die Logik in der Methode <code>use()</code> in der Klasse <code>Resource</code> implementieren.

Hinweis

## Wie soll das Programm funktionieren?
Es gibt **5 Threads**, die gleichzeitig die **Methode** `use()` ausführen möchten. Mit einem `Semaphore` muss die gleichzeitige Ausführung jedoch auf **2 Threads** beschränkt werden. Sobald ein **Thread** das `Semaphore` freigibt, kann ein anderer Thread mit der Ausführung dieser **Methode** beginnen. Zur besseren Veranschaulichung in diesem Szenario wird empfohlen, innerhalb der **Methode** `use()` eine Verzögerung einzubauen.

Dieser Kurs richtet sich an alle, die ihr Wissen über Multithreading erweitern und dessen Möglichkeiten nutzen möchten, um effiziente, leistungsstarke Anwendungen zu entwickeln. Sie tauchen in grundlegende Konzepte, praktische Techniken und bewährte Methoden des Multithreadings ein, um komplexe Nebenläufigkeitsprobleme souverän zu meistern.

In diesem Abschnitt werden die grundlegenden Konzepte der Nebenläufigkeit in Java behandelt, mit Schwerpunkt auf der Erstellung und Verwaltung von Threads sowie dem Einsatz von Synchronisationstechniken zur Vermeidung von Konflikten. Zudem wird erläutert, wie wichtige Schlüsselwörter und Methoden genutzt werden, um eine genaue und zuverlässige Ausführung nebenläufiger Programme zu gewährleisten und ein solides Verständnis für den effektiven Umgang mit Nebenläufigkeit in Anwendungen zu vermitteln.

Dieser Abschnitt behandelt synchronisierte Collections in Java, erläutert deren Zweck sowie die häufigsten Nebenläufigkeitsprobleme, die sie lösen sollen. Sie erhalten Einblicke in die Funktionsweise dieser Collections, deren Bedeutung in Multithread-Umgebungen und wie sie eine sichere und konsistente Datenverarbeitung bei gemeinsamem Ressourcenzugriff durch mehrere Threads gewährleisten.

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 wird von praktischen Übungen begleitet, die das Verständnis festigen und die Anwendung des theoretischen Wissens auf reale Szenarien unterstützen.

In diesem Abschnitt werden grundlegende Muster und Praktiken der nebenläufigen Programmierung wie Producer-Consumer, Fork/Join, ThreadLocal und asynchrone Programmierung mit CompletableFuture behandelt. Anhand von Beispielen werden die praktischen Ergebnisse dieser Ansätze veranschaulicht, wodurch praktische Erfahrungen vermittelt werden, die eine effektive Anwendung dieser Techniken in realen Anwendungen ermöglichen.

Herausforderung: Semaphore

Aufgabe

Bedingungen:

Wie soll das Programm funktionieren?

Awesome!

Herausforderung: Semaphore

Aufgabe

Bedingungen:

Wie soll das Programm funktionieren?