java 50 lines · 7 steps

A thread-safe LRU cache in Java

A LinkedHashMap in access order plus a read-write lock gives a bounded, concurrent least-recently-used cache.

Explained by highlit

Intermediate lru-cache concurrency linkedhashmap eviction locking

1import java.util.LinkedHashMap;
2import java.util.Map;
3import java.util.concurrent.locks.ReentrantReadWriteLock;
4 
5public class LruCache<K, V> {
6 
  private final int capacity;
  private final Map<K, V> cache;
  private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
10 
  public LruCache(int capacity) {
      if (capacity <= 0) {
          throw new IllegalArgumentException("capacity must be positive");
      }
      this.capacity = capacity;
      this.cache = new LinkedHashMap<>(capacity, 0.75f, true) {
          @Override
          protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {
              return size() > LruCache.this.capacity;
          }
      };
  }
23 
  public V get(K key) {
      lock.writeLock().lock();
      try {
          return cache.get(key);
      } finally {
          lock.writeLock().unlock();
      }
  }
32 
  public void put(K key, V value) {
      lock.writeLock().lock();
      try {
          cache.put(key, value);
      } finally {
          lock.writeLock().unlock();
      }
  }
41 
  public int size() {
      lock.readLock().lock();
      try {
          return cache.size();
      } finally {
          lock.readLock().unlock();
      }
  }
50}

01 / 01

STEP 01

Walkthrough

Space play ←→ step click any line

Three takeaways

1LinkedHashMap in access-order mode does the LRU bookkeeping for you — reordering entries on every access.
2Overriding removeEldestEntry turns a plain map into a self-evicting bounded cache.
3Reads that mutate access order must take a write lock, since they change the map's internal state.

Related explainers

java

@Component
public class RegionCacheWarmer implements SmartInitializingSingleton {
 
    private static final Logger log = LoggerFactory.getLogger(RegionCacheWarmer.class);

Warming a Spring cache at startup

caching startup-hook dependency-injection

Intermediate 7 steps

package breaker
 
import (
	"errors"

How a circuit breaker works in Go

circuit-breaker state-machine concurrency

Intermediate 8 steps

java

public final class EmailNormalizer {
 
    private static final Pattern EMAIL_PATTERN = Pattern.compile(
        "^[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,}$"

Normalizing email addresses in Java

validation regex normalization

Intermediate 8 steps

ruby

module UniqueJob
  extend ActiveSupport::Concern
 
  class_methods do

Deduplicating Active Job enqueues in Rails

concurrency idempotency caching

Advanced 9 steps

java

@RestController
@RequestMapping("/api/products")
@RequiredArgsConstructor
public class ProductBatchController {

Batch JSON Merge Patch in Spring

json-merge-patch rest-api partial-update

Intermediate 8 steps

java

public class TimedFetchService {
 
    private final ExecutorService executor = Executors.newFixedThreadPool(8);
    private final HttpClient httpClient = HttpClient.newHttpClient();