# Uppgift
Föreställ dig att du har en **resurs** som kan nås av **endast två trådar** samtidigt. Din uppgift är att **skapa ett program** som använder en `semaphore` för att **kontrollera åtkomst** till denna resurs.

## Villkor:
1. Du har en **klass** `Resource` med en **metod** `use()` som **simulerar** användning av en resurs, till exempel genom att **skriva ut ett meddelande** och införa en **fördröjning**;
2. Du har en **klass** `Worker` som **implementerar** `Runnable`; i dess **metod** `run()` kommer den att försöka få åtkomst till **resursen** med hjälp av en `semaphore`;
3. I **klassen** `SemaphoreExample` har du en **metod** `main()` som initierar en `semaphore` med tillstånd för **två trådar**, tillsammans med flera **arbetartrådar** som försöker få åtkomst till resursen;
4. **Säkerställ att högst två trådar** kan använda resursen samtidigt.

<b>Vänligen ändra ingenting! </b>Du behöver endast implementera metoden <code>run()</code> i klassen <code>Worker</code> samt implementera logiken i metoden <code>use()</code> i klassen <code>Resource</code>. 

Notering

## Hur ska programmet fungera?
Du har **5 trådar** som vill köra metoden `use()` samtidigt, men med en `Semaphore` **måste du begränsa** den samtidiga exekveringen till **2 trådar**. Så snart en **tråd** släpper `Semaphore`, kan en annan tråd börja köra denna **metod**. För ökad tydlighet i detta scenario **rekommenderas** det att införa en fördröjning i metoden `use()`.

Denna kurs är utformad för dem som vill fördjupa sina kunskaper om multitrådning och utnyttja dess möjligheter för att bygga effektiva, högpresterande applikationer. Du kommer att fördjupa dig i grundläggande begrepp, praktiska tekniker och bästa praxis inom multitrådning, vilket ger dig möjlighet att säkert hantera komplexa samtidighetsproblem.

Detta avsnitt går igenom de grundläggande koncepten för multitrådning i Java, med fokus på skapande och hantering av trådar samt användning av synkroniseringstekniker för att undvika konflikter. Du får även lära dig hur du använder viktiga nyckelord och metoder för att säkerställa korrekt och tillförlitlig körning av multitrådade program, vilket ger en solid förståelse för hur du effektivt hanterar samtidighet i dina applikationer.

Detta avsnitt utforskar synkroniserade samlingar i Java, förklarar deras syfte och de vanliga samtidighetsproblem de är utformade för att lösa. Du får insikt i hur dessa samlingar fungerar, varför de är viktiga i flertrådade miljöer och hur de bidrar till säker och konsekvent datamanipulation när flera trådar har åtkomst till delade resurser.

Detta avsnitt behandlar hög-nivå synkroniseringsmekanismer i Java, såsom användning av Lock och Condition, semaforer, barriärer, atomära variabler och trådpooler med Executors. Varje ämne åtföljs av praktiska övningar som är utformade för att förstärka din förståelse och hjälpa dig att tillämpa den teoretiska kunskapen i verkliga scenarier.

Detta avsnitt utforskar grundläggande mönster och praxis för multitrådad programmering såsom producent–konsument, fork/join, ThreadLocal och asynkron programmering med CompletableFuture. Du kommer att arbeta igenom exempel och se de praktiska resultaten av dessa tillvägagångssätt, vilket ger dig praktisk erfarenhet som gör det möjligt att tillämpa dessa tekniker effektivt i verkliga applikationer.

Utmaning: Semafor

Uppgift

Villkor:

Hur ska programmet fungera?

Awesome!

Utmaning: Semafor

Uppgift

Villkor:

Hur ska programmet fungera?