# Opgave
Forestil dig, at du har en **ressource**, der kun kan tilgås af **to tråde** ad gangen. Din opgave er at **oprette et program**, der bruger en `semaphore` til at **kontrollere adgangen** til denne ressource.

## Betingelser:
1. Du har en **klasse** `Resource` med en **metode** `use()`, der **simulerer** brugen af en ressource, såsom at **udskrive en besked** og indføre en **forsinkelse**;
2. Du har en **klasse** `Worker`, der **implementerer** `Runnable`; i dens **metode** `run()` vil den forsøge at tilgå **ressourcen** ved hjælp af en `semaphore`;
3. I **klassen** `SemaphoreExample` har du en **metode** `main()`, der initialiserer en `semaphore` med tilladelser til **to tråde**, sammen med flere **arbejdertråde**, der vil forsøge at tilgå ressourcen;
4. **Sørg for, at højst to tråde** kan bruge ressourcen på et givent tidspunkt.

<b>Venligst ændr ikke noget! </b>Du skal kun implementere <code>run()</code>-metoden i <code>Worker</code>-klassen og også implementere logikken i <code>use()</code>-metoden i <code>Resource</code>-klassen.

Bemærk

## Hvordan skal programmet fungere?
Der er **5 tråde**, der ønsker at udføre `use()`-**metoden** samtidigt, men med en `Semaphore` skal den samtidige udførelse **begrænses** til **2 tråde**. Så snart en **tråd** frigiver `Semaphore`, kan en anden tråd begynde at udføre denne **metode**. For bedre klarhed i dette scenarie anbefales det at indføre en forsinkelse i `use()`-**metoden**.

Dette kursus er tilpasset dem, der ønsker at udvide deres viden om multitrådning og udnytte dets muligheder til at bygge effektive, højtydende applikationer. Du vil dykke ned i essentielle begreber, praktiske teknikker og bedste praksis inden for multitrådning, hvilket sætter dig i stand til sikkert at håndtere komplekse samtidighedsproblemer.

Dette afsnit vil gå i dybden med de grundlæggende begreber inden for multithreading i Java med fokus på oprettelse og håndtering af tråde samt brugen af synkroniseringsteknikker for at undgå konflikter. Du vil også lære at anvende væsentlige nøgleord og metoder for at sikre nøjagtig og pålidelig udførelse af multitrådede programmer, hvilket giver en solid forståelse af, hvordan samtidighed håndteres effektivt i dine applikationer.

Dette afsnit undersøger synchroniserede samlinger i Java, forklarer deres formål og de almindelige samtidighedsproblemer, de er designet til at løse. Du får indsigt i, hvordan disse samlinger fungerer, hvorfor de er essentielle i multitrådede miljøer, og hvordan de bidrager til sikker og konsistent datamanipulation, når flere tråde får adgang til delte ressourcer.

Dette afsnit dækker højniveausynkroniseringsmekanismer i Java, såsom brugen af Lock og Condition, semaforer, barrierer, atomare variabler og trådpooling med Executors. Hvert emne ledsages af praktiske øvelser, der er designet til at styrke din forståelse og hjælpe dig med at anvende den teoretiske viden i virkelige scenarier.

Dette afsnit udforsker grundlæggende mønstre og praksisser inden for multitrådet programmering såsom Producer-Consumer, Fork/Join, ThreadLocal og asynkron programmering med CompletableFuture. Du vil arbejde dig igennem eksempler og se de praktiske resultater af disse tilgange, hvilket giver dig praktisk erfaring, der gør dig i stand til effektivt at anvende disse teknikker i virkelige applikationer.

Udfordring: Semafor

Opgave

Betingelser:

Hvordan skal programmet fungere?

Awesome!

Udfordring: Semafor

Opgave

Betingelser:

Hvordan skal programmet fungere?