Paylaşılan duruma (state) erişimi nasıl senkronize edersiniz?

Question

Accepted Answer

**Senkronizasyon**, iş parçacıklarının (thread) paylaşılan değişken duruma erişimini koordine ederek işlemlerin tehlikeli şekilde iç içe geçmesini önler ve **yarış koşullarını** (race condition) engeller. Java, yerleşik `synchronized` anahtar sözcüğünden açık kilitler ve kilit-serbest atomiklere kadar çeşitli mekanizmalar sunmaktadır.

## synchronized — karşılıklı dışlama (intrinsic locks)

```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`, korunan kodu aynı anda yalnızca bir iş parçacığının yürütmesini sağlar (karşılıklı dışlama) ve **görünürlük** sağlar — bir iş parçacığının yaptığı değişiklikler diğerlerine görünür hale gelir (bellek bariyerini geçer).

## volatile — atomiklik olmadan görünürlük

```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`, bir değişkenin okuma/yazma işlemlerinin iş parçacıkları arasında görünür olmasını garantiler — ancak bileşik işlemleri (örneğin `count++`) atomik yapmaz. Basit bayraklar için kullanın, okuma-değiştirme-yazma işlemleri için değil.

## Atomic sınıfları — kilit-serbest atomiklik

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

Atomic sınıfları, kilitler olmadan iş parçacığı-güvenli işlemler sağlar — basit sayaçlar/toplayıcılar için genellikle `synchronized` kullanmaktan daha hızlıdır.

## Açık Kilitler — daha fazla kontrol

```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`, `synchronized` tarafından sunulmayan özellikleri sunar: `tryLock()` (engelleyici olmayan), zamanlı beklemeler, adillik ve okuma-yazma ayrılığı.

## Yönetilmesi gereken tehlikeler

```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
```

## Neden önemli

Senkronizasyon, birden fazla iş parçacığı paylaşılan değişken duruma eriştiğinde doğruluk için gereklidir — senkronizasyon olmadan, yarış koşulları veri bozulmasına ve sürükleme neredeyse imkânsız olan aralıklı hatalarına yol açar.

Araçları ve onların kesin garantilerini bilmek kritiktir: `synchronized` (karşılıklı dışlama + görünürlük), `volatile` (sadece görünürlük — atomiklik DEĞİL, yaygın bir yanılgı), atomic sınıfları (basit işlemler için kilit-serbest) ve açık Kilitler (ileri kontrol).

Eşit derecede önemli olan, tehlikeleri — **kilitlenme** (deadlock) ve aşırı senkronizasyonun performansı düşürmesi — anlamak ve minimum ve tutarlı şekilde senkronizasyon yapma disiplinidir.

Bu, eşzamanlı sunucu tarafı Java için temel, yüksek riskli bilgidir ve doğru şekilde çok iş parçacıklı kod yazabilen geliştiricileri ayırt eden derin bir mülakat konusudur.