Hur synkroniserar du åtkomst till delat tillstånd?

Question

Accepted Answer

**Synkronisering** koordinerar trådars åtkomst till delat muterbart tillstånd så att operationer inte överlappar farligt, vilket förhindrar **race conditions**. Java erbjuder flera mekanismer, från det inbyggda `synchronized`-nyckelordet till explicita lås och låsfria atomärer.

## synchronized — ömsesidig uteslutning (inbyggda lås)

```java
class BankAccount {
    private double balance;

// synchronized method — acquires the object's lock; only ONE thread at a time
    public synchronized void withdraw(double amount) {
        if (balance >= amount) {
            balance -= amount;   // protected — no interleaving
        }
    }
    // synchronized block — finer-grained, lock on a specific object
    public void deposit(double amount) {
        synchronized (this) {
            balance += amount;
        }
    }
}
```

`synchronized` säkerställer att endast en tråd kör den skyddade koden åt gången (ömsesidig uteslutning) och ger **synlighet** — ändringar av en tråd blir synliga för andra (det korsar minnebarriären).

## volatile — synlighet utan atomicitet

```java
private volatile boolean running = true;   // guarantees VISIBILITY across threads

public void stop() { running = false; }     // other threads see the change immediately
public void run() { while (running) { ... } } // without volatile, might never see false
```

`volatile` garanterar att läsningar/skrivningar av en variabel är synliga över trådar — men gör **INTE** sammansatta operationer (som `count++`) atomära. Använd det för enkla flaggor, inte för läs-modifiera-skriv.

## Atomic classes — låsfri atomicitet

```java
AtomicInteger counter = new AtomicInteger(0);
counter.incrementAndGet();        // atomic ++ without locking (uses CPU CAS instructions)
counter.compareAndSet(5, 10);     // atomic conditional update
```

Atomicklasser tillhandahåller trådäkra operationer utan lås — ofta snabbare än `synchronized` för enkla räknare/ackumulatorer.

## Explicita lås — mer kontroll

```java
ReentrantLock lock = new ReentrantLock();
lock.lock();
try {
    // critical section
} finally {
    lock.unlock();   // ALWAYS unlock in finally
}
// ReadWriteLock allows many concurrent readers but exclusive writers
```

`ReentrantLock` erbjuder funktioner som `synchronized` saknar: `tryLock()` (icke-blockerande), tidsbegränsade väntningar, rättvisa och läs-skrivuppseparation.

## Farorna att hantera

```text
⚠️ Deadlock — two threads each hold a lock the other needs → both stuck forever
   (avoid by always acquiring locks in a consistent order)
⚠️ Performance — over-synchronizing serializes everything, killing concurrency
   (synchronize the SMALLEST necessary section)
⚠️ Forgetting to unlock (with explicit Locks) → use try/finally
```

## Varför det spelar roll

Synkronisering är väsentlig för korrekthet när flera trådar åtkomst delat muterbart tillstånd — utan det producerar race conditions korrupt data och intermittenta, nästan omöjliga att felsöka fel.

Att kunna verktygen och deras exakta garantier är kritiskt: `synchronized` (ömsesidig uteslutning + synlighet), `volatile` (endast synlighet — INTE atomicitet, en vanlig missuppfattning), atomicklasser (låsfri för enkla operationer) och explicita lås (avancerad kontroll).

Lika viktigt är att förstå farorna — **deadlock** och översynkronisering som skadar prestanda — och disciplinen att synkronisera minimalt och konsekvent.

Detta är kärnkunskap på höga insatser för concurrency i serversionssida Java och ett djupt intervjuämne som särskiljer utvecklare som kan skriva korrekt flertrådig kod.