# Oppgave
Tenk deg at du har en **ressurs** som kun kan benyttes av **to tråder** samtidig. Din oppgave er å **lage et program** som bruker en `semaphore` for å **kontrollere tilgangen** til denne ressursen.

## Betingelser:
1. Du har en **klasse** `Resource` med en **metode** `use()` som **simulerer** bruk av en ressurs, for eksempel ved å **skrive ut en melding** og legge inn en **forsinkelse**;
2. Du har en **klasse** `Worker` som **implementerer** `Runnable`; i dens **metode** `run()` vil den forsøke å få tilgang til **ressursen** ved hjelp av en `semaphore`;
3. I **klassen** `SemaphoreExample` har du en **metode** `main()` som initialiserer en `semaphore` med tillatelser for **to tråder**, sammen med flere **arbeidertråder** som vil forsøke å få tilgang til ressursen;
4. **Sørg for at ikke mer enn to tråder** kan bruke ressursen samtidig.

<b>Vennligst ikke endre noe! </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.

Merk

## Hvordan skal programmet fungere?
Du har **5 tråder** som ønsker å kjøre `use()`-**metoden** samtidig, men med en `Semaphore` må du **begrense** samtidig kjøring til **2 tråder**. Så snart en **tråd** frigjør `Semaphore`, kan en annen tråd begynne å kjøre denne **metoden**. For bedre tydelighet i dette scenariet, er det **anbefalt** å legge inn en forsinkelse i `use()`-**metoden**.

Dette kurset er tilpasset for de som ønsker å utvide sin kunnskap om multitråding og utnytte dets muligheter for å bygge effektive, høytytende applikasjoner. Du vil fordype deg i sentrale konsepter, praktiske teknikker og beste praksis innen multitråding, slik at du trygt kan håndtere komplekse samtidighetsproblemer.

Denne delen tar for seg de grunnleggende konseptene innen multitråding i Java, med fokus på opprettelse og håndtering av tråder, samt bruk av synkroniseringsteknikker for å unngå konflikter. Du vil også lære hvordan du benytter essensielle nøkkelord og metoder for å sikre nøyaktig og pålitelig utførelse av multitrådede programmer, og gir et solid grunnlag for effektiv håndtering av samtidighet i dine applikasjoner.

Denne delen utforsker synkroniserte samlinger i Java, forklarer deres formål og de vanlige samtidighetsproblemene de er utviklet for å løse. Du får innsikt i hvordan disse samlingene fungerer, hvorfor de er essensielle i flertrådede miljøer, og hvordan de bidrar til sikker og konsistent datamanipulering når flere tråder får tilgang til delte ressurser.

Denne delen omhandler høynivå synkroniseringsmekanismer i Java, som bruk av Lock og Condition, semaforer, barrierer, atomiske variabler og trådpooling med Executors. Hvert tema ledsages av praktiske øvelser som skal styrke forståelsen og hjelpe deg å anvende den teoretiske kunnskapen i virkelige situasjoner.

Denne delen utforsker grunnleggende mønstre og praksiser innen multitrådet programmering, som produsent–konsument, fork/join, ThreadLocal og asynkron programmering med CompletableFuture. Du vil arbeide gjennom eksempler og se de praktiske resultatene av disse tilnærmingene, og oppnå praktisk erfaring som gjør deg i stand til å anvende disse teknikkene effektivt i virkelige applikasjoner.

Utfordring: Semafor

Oppgave

Betingelser:

Hvordan skal programmet fungere?

Utfordring: Semafor

Oppgave

Betingelser:

Hvordan skal programmet fungere?