ReadWriteLock untuk Skenario Pembaca-Penulis
Gunakan ReadWriteLock untuk mengizinkan pembacaan bersamaan sekaligus memastikan penulisan eksklusif dalam cache.
ReadWriteLock untuk Skenario Pembaca-Penulis adalah pelajaran Java Academy gratis di CoddyKit. Ini adalah pelajaran 2 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.
Masalah Pembaca-Penulis
Beberapa utas dapat membaca data bersama dengan aman secara bersamaan. Namun, penulisan memerlukan akses eksklusif — tidak boleh ada pembacaan atau penulisan bersamaan. ReadWriteLock memodelkan hal ini: beberapa pembaca bersamaan ATAU satu penulis eksklusif.
import java.util.concurrent.locks.*;
ReadWriteLock rwLock = new ReentrantReadWriteLock();
Lock readLock = rwLock.readLock();
Lock writeLock = rwLock.writeLock();Lock Baca: Akses Bersama
Beberapa utas dapat memegang lock baca secara bersamaan selama tidak ada utas yang memegang lock tulis:
class ReadableCache {
private final Map<String, String> cache = new HashMap<>();
private final ReadWriteLock lock = new ReentrantReadWriteLock();
String get(String key) {
lock.readLock().lock();
try {
return cache.get(key); // concurrent reads OK
} finally {
lock.readLock().unlock();
}
}
}Lock Tulis: Akses Eksklusif
Hanya satu utas yang dapat memegang lock tulis pada satu waktu. Semua pembaca dan penulis lain diblokir selama penulisan:
class WritableCache extends ReadableCache {
private final ReadWriteLock wLock = new ReentrantReadWriteLock();
private final Map<String, String> data = new HashMap<>();
void put(String key, String value) {
wLock.writeLock().lock();
try {
data.put(key, value); // exclusive write
} finally {
wLock.writeLock().unlock();
}
}
}Contoh Lengkap Cache
Tembolok yang aman untuk utas, dengan pembacaan yang dominan dan penulisan yang jarang:
class Cache<K,V> {
private final Map<K,V> map = new HashMap<>();
private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
V get(K key) {
lock.readLock().lock();
try { return map.get(key); }
finally { lock.readLock().unlock(); }
}
void put(K key, V value) {
lock.writeLock().lock();
try { map.put(key, value); }
finally { lock.writeLock().unlock(); }
}
int size() {
lock.readLock().lock();
try { return map.size(); }
finally { lock.readLock().unlock(); }
}
}Penurunan Lock
ReadWriteLock mendukung penurunan lock: memperoleh lock tulis → memperoleh lock baca → melepaskan lock tulis. Ini memungkinkan utas beralih dari penulisan eksklusif ke pembacaan bersama tanpa melepaskan lock:
ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
Lock r = rwl.readLock(), w = rwl.writeLock();
w.lock(); // acquire write
try {
// modify data
r.lock(); // acquire read WHILE holding write
} finally {
w.unlock(); // release write, now holding read only
}
try {
// safely read the just-written data
} finally {
r.unlock();
}Lock Baca Tidak Dapat Ditingkatkan
Peningkatan lock (baca → tulis) tidak didukung. Jika utas yang memegang lock baca mencoba memperoleh lock tulis, terjadi kebuntuan karena lock tulis menunggu SEMUA pembaca, termasuk dirinya sendiri:
// DEADLOCK: Do NOT do this
lock.readLock().lock();
try {
lock.writeLock().lock(); // DEADLOCK — waits for readLock to release
} finally {
lock.readLock().unlock();
}Kapan ReadWriteLock Membantu
ReadWriteLock bermanfaat ketika:
- Pembacaan jauh lebih banyak daripada penulisan
- Operasi pembacaan memerlukan waktu yang tidak sepele, misalnya kueri kompleks
ReadWriteLock dapat menurunkan performa ketika penulisan sering dilakukan (lock tulis memblokir semua pembaca) atau ketika operasi sangat cepat (ada overhead dari dua objek lock).
Membandingkan ReadWriteLock dengan Sinkronisasi
Sinkronisasi/ReentrantLock → hanya satu utas pada satu waktu (bahkan pembacaan bersamaan terblokir).
ReadWriteLock → beberapa pembaca bersamaan dan satu penulis eksklusif. Throughput pembacaan lebih baik dalam skenario yang didominasi pembacaan.
// synchronized: only one thread reads at a time
synchronized String get(String key) { return cache.get(key); }
// ReadWriteLock: many threads can read simultaneously
String get2(String key) {
lock.readLock().lock();
try { return cache.get(key); }
finally { lock.readLock().unlock(); }
}Pertimbangan Performa
Memperoleh dan melepaskan dua objek lock menambah overhead dibandingkan satu lock. Lakukan pembuatan profil sebelum menganggap ReadWriteLock lebih cepat. Dalam skenario yang didominasi pembacaan dengan operasi yang panjang, manfaatnya jelas. Untuk beban kerja yang cepat dan didominasi penulisan, ReentrantLock sederhana mungkin lebih cepat.
Alternatif ConcurrentHashMap
Untuk operasi peta sederhana, ConcurrentHashMap sering kali lebih cepat daripada HashMap + ReadWriteLock karena menggunakan lock internal pada tingkat segmen tanpa persaingan global:
// Often better than HashMap + ReadWriteLock for simple operations:
Map<String, String> concurrent = new ConcurrentHashMap<>();
concurrent.put("key", "value"); // thread-safe, no explicit lock
String v = concurrent.get("key"); // thread-safeKeadilan ReadLock
Secara default, ReentrantReadWriteLock tidak adil (pembaca dapat membuat penulis kelaparan). Gunakan konstruktor yang adil untuk mencegah kelaparan penulis:
// Fair: waiting writers are served before new readers
ReentrantReadWriteLock fairLock = new ReentrantReadWriteLock(true);
System.out.println(fairLock.isFair()); // truePemeriksaan Singkat
Dalam aplikasi yang didominasi pembacaan, apa keunggulan utama ReadWriteLock dibandingkan metode tersinkronisasi sederhana?
Ringkasan: ReadWriteLock
Inti pembelajaran:
- Beberapa pembacaan bersamaan ATAU satu penulisan eksklusif — tidak keduanya
- readLock.lock()/unlock() untuk pembacaan bersama
- writeLock.lock()/unlock() untuk penulisan eksklusif
- Penurunan lock didukung; peningkatan (baca→tulis) menyebabkan kebuntuan
- Paling cocok untuk pembacaan yang dominan dengan operasi yang tidak sepele; gunakan ConcurrentHashMap untuk peta sederhana
Pertanyaan yang Sering Diajukan
Apakah pelajaran “ReadWriteLock untuk Skenario Pembaca-Penulis” gratis?
Ya — teks lengkap “ReadWriteLock untuk Skenario Pembaca-Penulis” 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 “ReadWriteLock untuk Skenario Pembaca-Penulis”?
Gunakan ReadWriteLock untuk mengizinkan pembacaan bersamaan sekaligus memastikan penulisan eksklusif dalam cache. 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 2 dari 4.
Berapa lama pelajaran “ReadWriteLock untuk Skenario Pembaca-Penulis” 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