# Taak
Stel je hebt een **resource** die door **slechts twee threads** tegelijk benaderd mag worden. Je opdracht is om een **programma te maken** dat een `semaphore` gebruikt om de **toegang tot deze resource te regelen**.

## Voorwaarden:
1. Je hebt een `Resource` **klasse** met een `use()` **methode** die het gebruik van een resource **simuleert**, bijvoorbeeld door een **bericht te printen** en een **vertraging** toe te voegen;
2. Je hebt een `Worker` **klasse** die `Runnable` **implementeert**; in de `run()` **methode** probeert deze toegang te krijgen tot de **resource** met behulp van een `semaphore`;
3. In de `SemaphoreExample` **klasse** heb je een `main()` **methode** die een `semaphore` initialiseert met permissies voor **twee threads**, samen met meerdere worker **threads** die proberen toegang te krijgen tot de resource;
4. **Zorg ervoor dat nooit meer dan twee threads** de resource tegelijkertijd kunnen gebruiken.

<b>Wijzig niets!</b> Je hoeft alleen de <code>run()</code>-methode in de <code>Worker</code>-klasse te implementeren en de logica in de <code>use()</code>-methode in de <code>Resource</code>-klasse uit te werken.

Opmerking

## Hoe moet het programma werken?
Er zijn **5 threads** die gelijktijdig de `use()` **methode** willen uitvoeren, maar met een `Semaphore` moet de gelijktijdige uitvoering worden beperkt tot **2 threads**. Zodra een **thread** de `Semaphore` vrijgeeft, kan een andere thread beginnen met het uitvoeren van deze **methode**. Voor meer duidelijkheid in dit scenario wordt **aanbevolen** om een vertraging toe te voegen binnen de `use()` **methode**.

Deze cursus is bedoeld voor degenen die hun kennis van multithreading willen uitbreiden en de mogelijkheden ervan willen benutten om efficiënte, krachtige applicaties te bouwen. Je verdiept je in essentiële concepten, praktische technieken en best practices op het gebied van multithreading, waardoor je in staat bent om complexe problemen met gelijktijdigheid vol vertrouwen aan te pakken.

Deze sectie behandelt de fundamentele concepten van multithreading in Java, met de nadruk op het aanmaken en beheren van threads en het gebruik van synchronisatietechnieken om conflicten te voorkomen. U leert ook hoe u essentiële sleutelwoorden en methoden gebruikt om een nauwkeurige en betrouwbare uitvoering van multithreaded programma's te waarborgen, wat zorgt voor een solide begrip van het effectief omgaan met gelijktijdigheid in uw applicaties.

Deze sectie behandelt gesynchroniseerde collecties in Java, waarbij het doel en de veelvoorkomende gelijktijdigheidsproblemen die ze oplossen worden uitgelegd. U krijgt inzicht in de werking van deze collecties, waarom ze essentieel zijn in multithreaded omgevingen en hoe ze bijdragen aan veilige en consistente gegevensmanipulatie wanneer meerdere threads gedeelde bronnen benaderen.

Deze sectie behandelt high-level synchronisatiemechanismen in Java, zoals het gebruik van Lock en Condition, semaforen, barrières, atomische variabelen en thread pooling met Executors. Elk onderwerp wordt ondersteund door praktische oefeningen die zijn ontworpen om het begrip te versterken en de toepassing van theoretische kennis in realistische scenario's te bevorderen.

Deze sectie behandelt fundamentele patronen en praktijken van multithreaded programmeren, zoals producer-consumer, fork/join, ThreadLocal en asynchrone programmering met CompletableFuture. U werkt met voorbeelden en ziet de praktische resultaten van deze benaderingen, waardoor u praktische ervaring opdoet die u in staat stelt deze technieken effectief toe te passen in realistische toepassingen.

Uitdaging: Semafoor

Taak

Voorwaarden:

Hoe moet het programma werken?

Awesome!

Uitdaging: Semafoor

Taak

Voorwaarden:

Hoe moet het programma werken?