# java.lang.ref

***

**1. Weak Reference to Prevent Memory Leaks**

```java
import java.lang.ref.WeakReference;

class Example {
  private Object obj;

  public Example(Object obj) {
    this.obj = new WeakReference<>(obj).get();
  }

  // ...
}
```

**2. Soft Reference for Caching**

```java
import java.lang.ref.SoftReference;
import java.util.HashMap;

class Cache {
  private Map<String, SoftReference<Object>> cache = new HashMap<>();

  public Object get(String key) {
    SoftReference<Object> ref = cache.get(key);
    return ref == null ? null : ref.get();
  }

  // ...
}
```

**3. Phantom Reference for Garbage Collection**

```java
import java.lang.ref.PhantomReference;

class Example {
  private Object obj;

  public Example(Object obj) {
    this.obj = new PhantomReference<>(obj, new Runnable() {
      @Override
      public void run() {
        // Clean up resources associated with obj
      }
    }).get();
  }

  // ...
}
```

**4. WeakHashMap for Memory Optimization**

```java
import java.lang.ref.WeakHashMap;

class Example {
  private WeakHashMap<String, Object> map = new WeakHashMap<>();

  public Object get(String key) {
    return map.get(key);
  }

  // ...
}
```

**5. SoftHashMap for Caching in Memory**

```java
import java.lang.ref.SoftHashMap;

class Cache {
  private SoftHashMap<String, Object> cache = new SoftHashMap<>();

  public Object get(String key) {
    return cache.get(key);
  }

  // ...
}
```

**6. SoftConcurrentMap for Concurrent Caching**

```java
import java.lang.ref.SoftConcurrentMap;

class Cache {
  private SoftConcurrentMap<String, Object> cache = new SoftConcurrentMap<>();

  public Object get(String key) {
    return cache.get(key);
  }

  // ...
}
```

**7. Reference Queue for Monitoring Objects**

```java
import java.lang.ref.Reference;
import java.lang.ref.ReferenceQueue;

class Example {
  private ReferenceQueue<Object> queue = new ReferenceQueue<>();

  public void addReference(Reference<Object> ref) {
    queue.offer(ref);
  }

  // ...
}
```

**8. Finalize Method for Custom Cleanup**

```java
public class Example {
  protected void finalize() {
    // Clean up resources
  }

  // ...
}
```

**9. Cleaner for Explicit Resource Release**

```java
import java.lang.ref.Cleaner;
import java.lang.ref.Cleaner.Cleanable;

class Example {
  private Cleanable cleaner;

  public Example() {
    cleaner = Cleaner.create().register(this, () -> {
      // Clean up resources
    });
  }

  // ...
}
```

**10. WeakThreadLocal for Per-Thread Data**

```java
import java.lang.ref.WeakThreadLocal;

class Example {
  private static WeakThreadLocal<Object> data = new WeakThreadLocal<>();

  public static Object get() {
    return data.get();
  }

  public static void set(Object data) {
    Example.data.set(data);
  }

  // ...
}
```

**11. SoftThreadLocal for Per-Thread Data Caching**

```java
import java.lang.ref.SoftThreadLocal;

class Example {
  private static SoftThreadLocal<Object> data = new SoftThreadLocal<>();

  public static Object get() {
    return data.get();
  }

  public static void set(Object data) {
    Example.data.set(data);
  }

  // ...
}
```

**12. InheritableThreadLocal for Inheritable Per-Thread Data**

```java
import java.lang.ref.InheritableThreadLocal;

class Example {
  private static InheritableThreadLocal<Object> data = new InheritableThreadLocal<>();

  public static Object get() {
    return data.get();
  }

  public static void set(Object data) {
    Example.data.set(data);
  }

  // ...
}
```

**13. ThreadLocal for Per-Thread Data Storage**

```java
import java.lang.ref.ThreadLocal;

class Example {
  private static ThreadLocal<Object> data = new ThreadLocal<>();

  public static Object get() {
    return data.get();
  }

  public static void set(Object data) {
    Example.data.set(data);
  }

  // ...
}
```

**14. WeakReference for Memory Management**

```java
import java.lang.ref.WeakReference;

class Example {
  private WeakReference<Object> ref;

  public Example(Object obj) {
    ref = new WeakReference<>(obj);
  }

  // ...
}
```

**15. SoftReference for Memory Management**

```java
import java.lang.ref.SoftReference;

class Example {
  private SoftReference<Object> ref;

  public Example(Object obj) {
    ref = new SoftReference<>(obj);
  }

  // ...
}
```

**16. PhantomReference for Finalization**

```java
import java.lang.ref.PhantomReference;
import java.lang.ref.ReferenceQueue;

class Example {
  private ReferenceQueue<Object> queue = new ReferenceQueue<>();
  private PhantomReference<Object> ref;

  public Example(Object obj) {
    ref = new PhantomReference<>(obj, queue);
  }

  // ...
}
```

**17. WeakHashMap for Memory Optimization**

```java
import java.lang.ref.WeakHashMap;

class Example {
  private WeakHashMap<Object, Object> map = new WeakHashMap<>();

  public Object get(Object key) {
    return map.get(key);
  }

  public void put(Object key, Object value) {
    map.put(key, value);
  }

  // ...
}
```

**18. SoftHashMap for Caching**

```java
import java.lang.ref.SoftHashMap;

class Example {
  private SoftHashMap<Object, Object> map = new SoftHashMap<>();

  public Object get(Object key) {
    return map.get(key);
  }

  public void put(Object key, Object value) {
    map.put(key, value);
  }

  // ...
}
```

**19. IdentityHashMap for Key Identity**

```java
import java.util.IdentityHashMap;

class Example {
  private IdentityHashMap<Object, Object> map = new IdentityHashMap<>();

  public Object get(Object key) {
    return map.get(key);
  }

  public void put(Object key, Object value) {
    map.put(key, value);
  }

  // ...
}
```

**20. ConcurrentHashMap for Concurrent Access**

```java
import java.util.concurrent.ConcurrentHashMap;

class Example {
  private ConcurrentHashMap<Object, Object> map = new ConcurrentHashMap<>();

  public Object get(Object key) {
    return map.get(key);
  }

  public void put(Object key, Object value) {
    map.put(key, value);
  }

  // ...
}
```

**21. CopyOnWriteArrayList for Concurrent Iteration**

```java
import java.util.concurrent.CopyOnWriteArrayList;

class Example {
  private CopyOnWriteArrayList<Object> list = new CopyOnWriteArrayList<>();

  public Object get(int index) {
    return list.get(index);
  }

  public void add(Object element) {
    list.add(element);
  }

  // ...
}
```

**22. BlockingQueue for Inter-Thread Communication**

```java
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

class Example {
  private BlockingQueue<Object> queue = new LinkedBlockingQueue<>();

  public Object take() {
    return queue.take();
  }

  public void put(Object element) {
    queue.put(element);
  }

  // ...
}
```

**23. ArrayBlockingQueue for Bounded Buffer**

```java
import java.util.concurrent.ArrayBlockingQueue;

class Example {
  private ArrayBlockingQueue<Object> queue = new ArrayBlockingQueue<>(10);

  public Object take() {
    return queue.take();
  }

  public void put(Object element) {
    queue.put(element);
  }

  // ...
}
```

**24. LinkedBlockingDeque for Double-Ended Blocking Queue**

```java
import java.util.concurrent.LinkedBlockingDeque;

class Example {
  private LinkedBlockingDeque<Object> queue = new LinkedBlockingDeque<>();

  public Object take() {
    return queue.take();
  }

  public void put(Object element) {
    queue.put(element);
  }

  // ...
}
```

**25. PriorityQueue for Priority-Based Queue**

```java
import java.util.PriorityQueue;

class Example {
  private PriorityQueue<Object> queue = new PriorityQueue<>();

  public Object poll() {
    return queue.poll();
  }

  public void offer(Object element) {
    queue.offer(element);
  }

  // ...
}
```

**26. Executors for Thread Management**

```java
import java.util.concurrent.Executors;
import java.util.concurrent.ExecutorService;

class Example {
  private ExecutorService executor = Executors.newFixedThreadPool(10);

  public void execute(Runnable task) {
    executor.execute(task);
  }

  // ...
}
```

**27. ScheduledExecutorService for Scheduled Tasks**

```java
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.Executors;

class Example {
  private ScheduledExecutorService executor = Executors.newScheduledThreadPool(10);

  public void schedule(Runnable task, long delay, TimeUnit unit) {
    executor.schedule(task, delay, unit);
  }

  // ...
}
```

**28. CountDownLatch for Synchronizing Threads**

```java
import java.util.concurrent.CountDownLatch;

class Example {
  private CountDownLatch latch = new CountDownLatch(10);

  public void countDown() {
    latch.countDown();
  }

  public void await() {
    latch.await();
  }

  // ...
}
```

**29. CyclicBarrier for Synchronizing Threads**

```java
import java.util.concurrent.CyclicBarrier;

class Example {
  private CyclicBarrier barrier = new CyclicBarrier(10);

  public void await() {
    barrier.await();
  }

  // ...
}
```

**30. Semaphore for Controlling Thread Access**

```java
import java.util.concurrent.Semaphore;

class Example {
  private Semaphore semaphore = new Semaphore(10);

  public void acquire() {
    semaphore.acquire();
  }

  public void release() {
    semaphore.release();
  }

  // ...
}
```

**31. Lock for Thread Synchronization**

```java
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

class Example {
  private Lock lock = new ReentrantLock();

  public void lock() {
    lock.lock();
  }

  public void unlock() {
    lock.unlock();
  }

  // ...
}
```

**32. ReadWriteLock for Controlling Read and Write Access**

```java
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

class Example {
  private ReadWriteLock lock = new ReentrantReadWriteLock();

  public void readLock() {
    lock.readLock().lock();
  }

  public void readUnlock() {
    lock.readLock().unlock();
  }

  public void writeLock() {
    lock.writeLock().lock();
  }

  public void writeUnlock() {
    lock.writeLock().unlock();
  }

  // ...
}
```

**33. StampedLock for Optimistic Concurrency**

```java
import java.util.concurrent.locks.StampedLock;

class Example {
  private StampedLock lock = new StampedLock();

  public long readLock() {
    return lock.readLock();
  }

  public void readUnlock(long stamp) {
    lock.unlockRead(stamp);
  }

  public long writeLock() {
    return lock.writeLock();
  }

  public void writeUnlock(long stamp) {
    lock.unlockWrite(stamp);
  }

  // ...
}
```

**34. AtomicBoolean for Memory-Consistent Boolean**

```java
import java.util.concurrent.atomic.AtomicBoolean;

class Example {
  private AtomicBoolean flag = new AtomicBoolean();

  public boolean get() {
    return flag.get();
  }

  public boolean compareAndSet(boolean expect, boolean update) {
    return flag.compareAndSet(expect, update);
  }

  // ...
}
```

**35. AtomicInteger for Memory-Consistent Integer**

```java
import java.util.concurrent.atomic.AtomicInteger;

class Example {
  private AtomicInteger counter = new AtomicInteger();

  public int get() {
    return counter.get();
  }

  public int incrementAndGet() {
    return counter.incrementAndGet();
  }

  // ...
}
```

**36. AtomicLong for Memory-Consistent Long**

```java
import java.util.concurrent.atomic.AtomicLong;

class Example {
  private AtomicLong counter = new AtomicLong();

  public long get() {
    return counter.get();
  }

  public long incrementAndGet() {
    return counter.incrementAndGet();
  }

  // ...
}
```

**37. AtomicReference for Memory-Consistent Reference**

```java
import java.util.concurrent.atomic.AtomicReference;

class Example {
  private AtomicReference<Object> ref = new AtomicReference<>();

  public Object get() {
    return ref.get();
  }

  public boolean compareAndSet(Object expect, Object update) {
    return ref.compareAndSet(expect, update);
  }

  // ...
}
```

**38. AtomicMarkableReference for Memory-Consistent Reference with Mark**

```java
import java.util.concurrent.atomic.AtomicMarkableReference;

class Example {
  private AtomicMarkableReference<Object> ref = new AtomicMarkableReference<>(null, false);

  public Object get(boolean[] mark) {
    return ref.getReference(mark);
  }

  public boolean compareAndSet(Object expect, Object update, boolean expectMark, boolean updateMark) {
    return ref.compareAndSet(expect, update, expectMark, updateMark);
  }

  // ...
}
```

**39. AtomicIntegerFieldUpdater for Memory-Consistent Field Updates**

```java
import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;

class Example {
  private volatile int count;
  private static final AtomicIntegerFieldUpdater<Example> updater = AtomicIntegerFieldUpdater.newUpdater(Example.class, "count");

  public int getCount() {
    return updater.get(this);
  }

  public boolean compareAndSetCount(int expect, int update) {
    return updater.compareAndSet(this, expect, update);
  }

  // ...
}
```

**40. AtomicLongFieldUpdater for Memory-Consistent Field Updates**

```java
import java.util.concurrent.atomic.AtomicLongFieldUpdater;

class Example {
  private volatile long count;
  private static final AtomicLongFieldUpdater<Example> updater = AtomicLongFieldUpdater.newUpdater(Example.class, "count");

  public long getCount() {
    return updater.get(this);
  }

  public boolean compareAndSetCount(long expect, long update) {
    return updater.compareAndSet(this, expect, update);
  }

  // ...
}
```

**41. AtomicReferenceFieldUpdater for Memory-Consistent Field Updates**

```java
import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;

class Example {
  private volatile Object ref;
  private static final AtomicReferenceFieldUpdater<Example, Object> updater = AtomicReferenceFieldUpdater.newUpdater(Example.class, Object.class, "ref");

  public Object getRef() {
    return updater.get(this);
  }

  public boolean compareAndSetRef(Object expect, Object update) {
    return updater.compareAndSet(this, expect, update);
  }

  // ...
}
```

**42. VarHandle for Efficient Field Access**

```java
import java.lang.invoke.VarHandle;
import java.lang.invoke.MethodHandles;

class Example {
  private int count;

  public int getCount() {
    return (int) VarHandle.getVolatile(Example.class, this, "count");
  }

  public void setCount(int count) {
    VarHandle.setVolatile(Example.class, this, "count", count);
  }

  // ...
}
```

**43. Unsafe for Low-Level Memory Access**

```java
import sun.misc.Unsafe;

class Example {
  private static final Unsafe UNSAFE = Unsafe.getUnsafe();

  private long count;

  public int getCount() {
    return UNSAFE.getInt(this, UNSAFE.objectFieldOffset(Example.class.getDeclaredField("count")));
  }

  public void setCount(int count) {
    UNSAFE.putInt(this, UNSAFE.objectFieldOffset(Example.class.getDeclaredField("count")), count);
  }

  // ...
}
```

**44. MemoryBarrier for Memory Synchronization**

```java
import sun.misc.Unsafe;

class Example {
  private static final Unsafe UNSAFE = Unsafe.getUnsafe();

  private int count;

  public void updateCount() {
    UNSAFE.putOrderedInt(this, UNSAFE.objectFieldOffset(Example.class.getDeclaredField("count")), 10);
  }

  public int getCount() {
    return UNSAFE.getOrderedInt(this, UNSAFE.objectFieldOffset(Example.class.getDeclaredField("count")));
  }

  // ...
}
```

**45. Volatile for Memory Visibility**

```java
class Example {
  private volatile int count;

  public void updateCount() {
    count = 10;
  }

  public int getCount() {
    return count;
  }

  // ...
}
```

**46. Synchronized for Thread Safety**

```java
class Example {
  private int count;

  public synchronized void updateCount() {
    count = 10;
  }

  public synchronized int getCount() {
    return count;
  }

  // ...
}
```

**47. Lock-Free Data Structures for Concurrent Access**

```java
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CopyOnWriteArrayList;

class Example {
  private ConcurrentHashMap<Object, Object> map = new ConcurrentHashMap<>();
  private CopyOnWriteArrayList<Object> list = new CopyOnWriteArrayList<>();

  // ...
}
```

**48. ThreadLocal for Per-Thread Storage**

```java
import java.lang.ThreadLocal;

class Example {
  private static ThreadLocal<Object> data = new ThreadLocal<>();

  public static Object getData() {
    return data.get();
  }

  public static void setData(Object data) {
    Example.data.set(data);
  }

  // ...
}
```

**49. InheritableThreadLocal for Per-Thread Storage with Inheritance**

```java
import java.lang.InheritableThreadLocal;

class Example {
  private static InheritableThreadLocal<Object> data = new InheritableThreadLocal<>();

  public static Object getData() {
    return data.get();
  }

  public static void setData(Object data) {
    Example.data.set(data);
  }

  // ...
}
```

**50. Thread-Safe Collections for Concurrent Access**

```java
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CopyOnWriteArrayList;

class Example {
  private ConcurrentHashMap<Object, Object> map = new ConcurrentHashMap<>();
  private CopyOnWriteArrayList<Object> list = new CopyOnWriteArrayList<>();

  // ...
}
```