# Uppgift:
Implementering av **multitrådat** system för registrering av sidvisningar.

### Beskrivning:
Det är nödvändigt att **skapa ett program** för att hålla **reda på** antalet besök på olika sidor på webbplatsen. Programmet ska **fungera korrekt** i en **multitrådad** miljö, där flera trådar samtidigt kan öka **besöksräknare** för olika sidor.

# Krav:
- Använd `ConcurrentHashMap` för att lagra data om **sidbesök**;
- Implementera en **metod** som ökar besöksräknaren för en given sida. `incrementVisit()`;
- Implementera en metod som returnerar det aktuella **antalet besök** för en given sida. `getVisitCount()`;
- Skapa **flera trådar** som **ökar** besöksräknarna samtidigt. (Detta är implementerat i **klassen** `Main`, du behöver förstå vad som händer där).

## Tips:
- Använd `ConcurrentHashMap` för att lagra data där nyckeln är sidans **URL** och värdet är **antalet besök**;
- Använd metoderna `compute()` eller `merge()` för att **atomärt uppdatera räknare** i `ConcurrentHashMap`.


**Du behöver** slutföra **metoderna** i klassen `PageVisitCounterImpl` och därefter **köra** testerna i klassen `PageVisitCounterTest`.

När du har **slutfört uppgiften** korrekt ska alla tester **klara sig**.

När du har gjort allt korrekt kan du försöka redigera **raden** där `ConcurrentMap` deklareras i **klassen** `PageVisitCounterImpl` och **se vad som händer**.

Notering

Det vill säga, du behöver **ersätta denna rad** här med `ConcurrentMap`-implementeringen.

cHJpdmF0ZSBmaW5hbCBDb25jdXJyZW50TWFwPFN0cmluZywgSW50ZWdlcj4gdmlzaXRDb3VudHMgPSBuZXcgQ29uY3VycmVudEhhc2hNYXA8PigpOw==

I detta exempel, med användning av den vanliga `Map`

cHJpdmF0ZSBmaW5hbCBNYXA8U3RyaW5nLCBJbnRlZ2VyPiB2aXNpdENvdW50cyA9IG5ldyBIYXNoTWFwPD4oKTs=

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: Concurrentmap

Uppgift:

Beskrivning:

Krav:

Tips: