0Pricing
Java Academy · Ders

ReentrantLock ve synchronized Karşılaştırması

ReentrantLock özelliklerini (tryLock, lockInterruptibly, adalet) synchronized anahtar sözcüğüyle karşılaştırın.

ReentrantLock ve synchronized Karşılaştırması, CoddyKit'te ücretsiz bir Java Academy dersidir. Bu, 4 dersinin 1. dersidir. Aşağıdan dersin tamamını ücretsiz okuyabilir, sonra tarayıcıda yerleşik kod editörü ve 7/24 yapay zeka koçu ile uygulamalı olarak pratik yapabilirsin. Bu, Java Academy öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. Java Academy kursu toplamda 4 dersten oluşur.

synchronized Anahtar Sözcüğü

Java'nın synchronized anahtar sözcüğü, nesnenin yerleşik kilidini (monitörünü) kullanarak karşılıklı dışlama sağlar. Basittir ancak sınırlıdır — zaman aşımı, adillik ve kesilebilirlik sunmaz.

class Counter {
    private int count = 0;
    
    synchronized void increment() {
        count++; // only one thread at a time
    }
    
    synchronized int get() { return count; }
}

Counter c = new Counter();
// Multiple threads can safely call increment()

ReentrantLock Temelleri

ReentrantLock, java.util.concurrent.locks paketinden açık bir kilittir. synchronized ile aynı karşılıklı dışlamayı sağlar, ancak daha fazla denetim sunar. Kilit, finally bloğunda el ile serbest bırakılmalıdır.

import java.util.concurrent.locks.*;

class SafeCounter {
    private int count = 0;
    private final ReentrantLock lock = new ReentrantLock();
    
    void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock(); // always release in finally!
        }
    }
    
    int get() {
        lock.lock();
        try { return count; }
        finally { lock.unlock(); }
    }
}

tryLock: Engellemeden Kilit Edinme

tryLock(), engelleme olmadan kilidi edinmeyi dener. Başarılı olursa true, kilit başka bir iş parçacığı tarafından tutuluyorsa false döndürür.

ReentrantLock lock = new ReentrantLock();

if (lock.tryLock()) {
    try {
        System.out.println("Got the lock, doing work");
    } finally {
        lock.unlock();
    }
} else {
    System.out.println("Lock busy, skipping or retrying");
}

Zaman Aşımlı tryLock

Kilidi edinmek için belirtilen süreye kadar bekleyin:

try {
    if (lock.tryLock(500, TimeUnit.MILLISECONDS)) {
        try {
            // work with protected resource
            System.out.println("Acquired within 500ms");
        } finally {
            lock.unlock();
        }
    } else {
        System.out.println("Timed out waiting for lock");
    }
} catch (InterruptedException e) {
    Thread.currentThread().interrupt();
}

lockInterruptibly

lockInterruptibly(), iş parçacığı kesintiye uğratılmadığı sürece kilidi edinir — kilit için bekleyen iptal edilebilir görevler açısından kullanışlıdır:

try {
    lock.lockInterruptibly(); // throws InterruptedException if interrupted
    try {
        // do work
    } finally {
        lock.unlock();
    }
} catch (InterruptedException e) {
    System.out.println("Interrupted while waiting for lock");
    Thread.currentThread().interrupt();
}

Yeniden Giriş

Hem synchronized hem de ReentrantLock yeniden girilebilirdir — kilidi zaten tutan bir iş parçacığı, kilitlenmeye yol açmadan kilidi yeniden edinebilir:

synchronized void outer() {
    System.out.println("outer");
    inner(); // same thread re-enters — OK
}

synchronized void inner() {
    System.out.println("inner"); // same lock, same thread
}

// ReentrantLock:
ReentrantLock lock = new ReentrantLock();
lock.lock();
lock.lock(); // acquire again — hold count = 2
lock.unlock(); // hold count = 1
lock.unlock(); // hold count = 0, lock released

Adillik İlkesi

Erişimi FIFO sırasına göre vermek için adil bir ReentrantLock oluşturun — daha düşük aktarım hızı pahasına iş parçacıklarının aç kalmasını önler:

// Unfair (default): no ordering guarantee, better throughput
ReentrantLock unfair = new ReentrantLock();

// Fair: threads acquire in arrival order
ReentrantLock fair = new ReentrantLock(true);

System.out.println(fair.isFair()); // true

Koşul Değişkenleri

ReentrantLock, wait()/notify() yöntemlerinden daha esnek olan Condition nesneleri sağlar:

ReentrantLock lock2 = new ReentrantLock();
Condition notEmpty = lock2.newCondition();
Queue<String> queue = new LinkedList<>();

// Producer
lock2.lock();
try {
    queue.offer("item");
    notEmpty.signal(); // wake one waiting thread
} finally { lock2.unlock(); }

// Consumer
lock2.lock();
try {
    while (queue.isEmpty()) notEmpty.await(); // wait & release lock
    System.out.println(queue.poll());
} finally { lock2.unlock(); }

ReentrantLock ile synchronized Ne Zaman Kullanılmalı

Şu durumlarda synchronized kullanın:

  • Basit karşılıklı dışlama gerekiyorsa
  • Zaman aşımı, adillik veya kesilebilirlik gerekmiyorsa

Şu durumlarda ReentrantLock kullanın:

  • tryLock() veya tryLock(timeout) gerekiyorsa
  • lockInterruptibly() gerekiyorsa
  • Adil sıralama gerekiyorsa
  • Birden çok Condition değişkeni gerekiyorsa

Kilit Sayısı ve İzleme

ReentrantLock tanılama yöntemleri sağlar:

ReentrantLock lock3 = new ReentrantLock();
lock3.lock();
lock3.lock(); // reentrant — hold count 2

System.out.println(lock3.getHoldCount());    // 2
System.out.println(lock3.isHeldByCurrentThread()); // true
System.out.println(lock3.isLocked());        // true
System.out.println(lock3.getQueueLength());  // 0 (no waiting threads)

lock3.unlock();
lock3.unlock(); // fully released

Yaygın Hata: Kilit Almadan Kilidi Açma

Geçerli iş parçacığı kilidi tutmuyorken unlock() çağrılırsa IllegalMonitorStateException fırlatılır. lock/unlock çağrılarını her zaman eşleştirin veya try-finally kullanın:

ReentrantLock lock4 = new ReentrantLock();
try {
    // If lock() is never called (e.g., skipped by exception before this line)
    lock4.unlock(); // throws IllegalMonitorStateException
} catch (IllegalMonitorStateException e) {
    System.out.println("Must lock before unlock!");
}

Hızlı Kontrol

Kilit kullanılamıyorsa engellemeden hemen dönmek veya kilidi edinmek için hangi ReentrantLock yöntemi kullanılır?

Özet: ReentrantLock ile synchronized Karşılaştırması

Temel çıkarımlar:

  • Her ikisi de karşılıklı dışlama ve yeniden giriş sağlar
  • ReentrantLock şunları ekler: tryLock, lockInterruptibly, adillik ve Condition'lar
  • Her zaman finally bloğunda serbest bırakın
  • synchronized daha basittir — özellikleri yeterliyse onu tercih edin
  • Gelişmiş senaryolar için ReentrantLock kullanın: zaman aşımları, kesilebilirlik ve birden çok koşul

Sıkça Sorulan Sorular

“ReentrantLock ve synchronized Karşılaştırması” dersi ücretsiz mi?

Evet — “ReentrantLock ve synchronized Karşılaştırması” dersin tüm metni burada web'de ücretsiz olarak okunabilir. Etkileşimli olarak pratik yapmak (yerleşik kod editörü ve 7/24 yapay zeka koçu) ve Java Academy kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. Java Academy kursu toplamda 4 dersten oluşur.

“ReentrantLock ve synchronized Karşılaştırması” dersinde ne öğreneceğim?

ReentrantLock özelliklerini (tryLock, lockInterruptibly, adalet) synchronized anahtar sözcüğüyle karşılaştırın. Java Academy ile uygulamalı kodu tarayıcıda doğrudan çalıştırarak pratik yaparsın ve 7/24 yapay zeka koçu dersi çalışırken sorularını yanıtlar.

Java Academy öğrenmeye başlamak için deneyim gerekli mi?

Önceden deneyim gerekmez. CoddyKit'te Java Academy, başlangıçtan ileri seviyeye kadar yapılandırıldığı için buradan başlayabilir veya başından başlayıp kendi hızında ilerleme yapabilirsin. Bu, 4 dersinin 1. dersidir.

“ReentrantLock ve synchronized Karşılaştırması” dersi ne kadar sürer?

Çoğu CoddyKit dersi yaklaşık 5–10 dakika sürer. Her biri kısa ve etkileşimli olduğu için sabit ilerleme yaparsın ve web ile uygulama arasında tam olarak bıraktığın yerden devam edebilirsin.

Bu Java Academy dersinde kod yazıp çalıştırabilir miyim?

Evet. Her Java Academy dersi yerleşik bir kod editörü içerir, bu sayede tarayıcıda gerçek kod yazıp çalıştırabilir ve anlık yapay zeka geri bildirimi alırsın — yerel kurulum gerekli değildir.

Bu kursun tüm dersleri

  1. ReentrantLock ve synchronized Karşılaştırması
  2. Okuyucu-Yazıcı Senaryoları için ReadWriteLock
  3. Atomik Değişkenler: Kilitsiz Güncellemeler
  4. StampedLock ve İyimser Okumalar
← Java Academy Sayfasına Dön