Synchronization: Thread Güvenliği (Thread Safety) ve Lock Mekanizmaları

[crazy_coder]

Synchronization: Thread Güvenliği ve Kilitler​

---

1. synchronized Anahtar Kelimesi​

Java'nın en temel kilit mekanizmasıdır. Bir metodu veya bir kod bloğunu synchronized olarak işaretlediğinizde, o bölgeye aynı anda sadece bir thread girebilir. Diğerleri, içerideki thread işini bitirip kilidi bırakana kadar kapıda bekler.

Synchronized Method: Tüm metodu kilitler.

Synchronized Block: Sadece kritik olan satırları kilitler (Daha performanslıdır).

private int sayac = 0;

// Metod seviyesinde kilit
public synchronized void artir() {
sayac++;
}

// Blok seviyesinde kilit (Daha spesifik)
public void guvenliIslem() {
synchronized(this) {
// Sadece burası thread-safe
}
}

2. ReentrantLock: Daha Esnek Kontrol​

synchronized bazen çok katıdır. Java 5 ile gelen ReentrantLock sınıfı, bize daha fazla kontrol imkanı sunar:

tryLock(): Kilit müsaitse al, değilse beklemeden başka işe devam et.

lockInterruptibly(): Beklerken thread'in durdurulabilmesine izin ver.

Adil Kilit (Fairness): En uzun süre bekleyen thread'e öncelik ver.

Lock kilit = new ReentrantLock();

public void veriGuncelle() {
kilit.lock(); // Kilidi al
try {
// Kritik işlemler
} finally {
kilit.unlock(); // Hata olsa bile kilidi mutlaka bırak!
}
}

3. Volatile Değişkenler​

Bazı durumlarda tam bir kilit (Lock) yerine sadece verinin güncelliği önemlidir. volatile anahtar kelimesi, bir değişkenin değerinin her zaman ana bellekten (RAM) okunmasını sağlar. İşlemci çekirdeklerinin kendi yerel önbelleklerindeki (CPU Cache) eski veriyi kullanmasını engeller.

Dikkat: volatile sadece görünürlüğü (visibility) sağlar, atomik işlemleri (örn: i++) garanti etmez.

4. Atomic Değişkenler (java.util.concurrent.atomic)​

Eğer sadece basit bir sayacı artırmak veya değer atamak istiyorsanız, ağır kilit mekanizmaları (Lock/Synchronized) kullanmak performansı düşürür. Java, düşük seviyeli CAS (Compare-And-Swap) algoritmasını kullanan atomik sınıflar sunar.

AtomicInteger atomikSayac = new AtomicInteger(0);

// Thread-safe artırım
atomikSayac.incrementAndGet();

5. Deadlock (Ölümcül Kilitlenme) Riski​

Senkronizasyonun en büyük tehlikesi Deadlock'tur. İki thread'in, birbirlerinin elindeki kilidi beklemesi durumunda sistem sonsuza kadar kilitlenir.

Thread A: Kilit 1'i tutuyor, Kilit 2'yi bekliyor.

Thread B: Kilit 2'yi tutuyor, Kilit 1'i bekliyor.

---

Sonuç

Thread güvenliği sağlamak bir dengedir. Çok az kilit veri bozulmasına, çok fazla kilit ise uygulamanın yavaşlamasına (performance bottleneck) yol açar. Kural basit: Mümkünse Atomic değişkenleri, karmaşık işlemlerde Synchronized bloklarını, çok detaylı kontrol gerekiyorsa ReentrantLock'u tercih etmelisiniz.