Java Academy · Pelajaran

ReentrantLock vs synchronized

Bandingkan fitur ReentrantLock (tryLock, lockInterruptibly, fairness) dengan kata kunci synchronized.

ReentrantLock vs synchronized adalah pelajaran Java Academy gratis di CoddyKit. Ini adalah pelajaran 1 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Java Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Java Academy mencakup 4 pelajaran total.

Kata Kunci Sinkronisasi

Kata kunci synchronized pada Java menyediakan eksklusi mutual menggunakan kunci intrinsik objek (monitor). Sederhana, tetapi terbatas — tidak ada batas waktu, keadilan, atau kemampuan untuk diinterupsi.

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()

Dasar-Dasar ReentrantLock

ReentrantLock adalah lock eksplisit dari java.util.concurrent.locks. Lock ini menyediakan eksklusi mutual yang sama seperti synchronized, tetapi dengan kontrol yang lebih besar. Lock harus dilepaskan secara manual di dalam blok yang selalu dijalankan.

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(); }
    }
}

Akuisisi Tanpa Pemblokiran dengan tryLock

tryLock() mencoba memperoleh lock tanpa memblokir. Mengembalikan benar jika berhasil dan salah jika lock dimiliki oleh utas lain.

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");
}

tryLock dengan Batas Waktu

Tunggu hingga waktu yang ditentukan untuk memperoleh lock:

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() memperoleh lock kecuali utas diinterupsi — berguna untuk tugas yang dapat dibatalkan dan sedang menunggu lock:

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();
}

Reentransi

Baik synchronized maupun ReentrantLock bersifat reentrant — utas yang sudah memegang lock dapat memperolehnya lagi tanpa menyebabkan kebuntuan:

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

Kebijakan Keadilan

Buat ReentrantLock yang adil untuk memberikan akses dalam urutan FIFO — mencegah kelaparan utas dengan konsekuensi laju pemrosesan yang lebih rendah:

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

Variabel Kondisi

ReentrantLock menyediakan objek Condition — lebih fleksibel daripada wait()/notify():

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(); }

Kapan Menggunakan ReentrantLock vs Sinkronisasi

Gunakan sinkronisasi ketika:

Diperlukan eksklusi mutual sederhana
Tidak diperlukan batas waktu, keadilan, atau kemampuan untuk diinterupsi

Gunakan ReentrantLock ketika:

Diperlukan tryLock() atau tryLock() dengan batas waktu
Diperlukan lockInterruptibly()
Diperlukan pengurutan yang adil
Diperlukan beberapa variabel kondisi

Jumlah Lock dan Pemantauan

ReentrantLock menyediakan metode diagnostik:

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

Kesalahan Umum: Membuka Lock Tanpa Menguncinya

Memanggil unlock() saat utas saat ini tidak memegang lock akan menimbulkan IllegalMonitorStateException. Selalu pasangkan lock/unlock atau gunakan blok yang menjamin pelepasan lock:

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!");
}

Pemeriksaan Singkat

Metode ReentrantLock mana yang memungkinkan utas memperoleh lock atau langsung mengembalikan hasil tanpa memblokir jika lock tidak tersedia?

Ringkasan: ReentrantLock vs Sinkronisasi

Inti pembelajaran:

Keduanya menyediakan eksklusi mutual dan reentransi
ReentrantLock menambahkan: tryLock, lockInterruptibly, keadilan, dan variabel kondisi
Selalu lepaskan lock di dalam blok yang selalu dijalankan
Sinkronisasi lebih sederhana — pilihlah ini jika fiturnya sudah memadai
Gunakan ReentrantLock untuk skenario lanjutan: batas waktu, kemampuan untuk diinterupsi, dan beberapa kondisi

Pertanyaan yang Sering Diajukan

Apakah pelajaran “ReentrantLock vs synchronized” gratis?

Ya — teks lengkap “ReentrantLock vs synchronized” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Java Academy, upgrade ke CoddyKit PRO. Kursus Java Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “ReentrantLock vs synchronized”?

Bandingkan fitur ReentrantLock (tryLock, lockInterruptibly, fairness) dengan kata kunci synchronized. Kamu berlatih Java Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Java Academy?

Tidak diperlukan pengalaman sebelumnya. Java Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 1 dari 4.

Berapa lama pelajaran “ReentrantLock vs synchronized” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Java Academy ini?

Ya. Setiap pelajaran Java Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

ReentrantLock vs synchronized
ReadWriteLock untuk Skenario Pembaca-Penulis
Variabel Atomik: Pembaruan Tanpa Lock
StampedLock dan Pembacaan Optimistis

← Kembali ke Java Academy