1
Object obj = new Object(); // 强引用
2
obj = null; // 只有断开强引用，对象才可能被回收

1
import java.lang.ref.SoftReference;
2

3
// 创建软引用
4
SoftReference<byte[]> cache = new SoftReference<>(new byte[1024 * 1024]);
5

6
// 使用时需要检查是否已被回收
7
byte[] data = cache.get();
8
if (data == null) {
9
    // 已被 GC 回收，需要重新加载
10
    data = new byte[1024 * 1024];
11
    cache = new SoftReference<>(data);
12
}

1
import java.lang.ref.WeakReference;
2

3
WeakReference<Object> ref = new WeakReference<>(new Object());
4

5
System.gc(); // GC 之后 ref.get() 大概率返回 null
6
System.out.println(ref.get()); // null

1
import java.lang.ref.PhantomReference;
2
import java.lang.ref.ReferenceQueue;
3

4
ReferenceQueue<Object> queue = new ReferenceQueue<>();
5
PhantomReference<Object> ref = new PhantomReference<>(new Object(), queue);
6

7
// 永远返回 null
8
System.out.println(ref.get()); // null
9

10
// 通过队列检测回收
11
Reference<?> r = queue.poll();
12
if (r != null) {
13
    // 对象已被 GC，执行清理
14
    cleanup();
15
}

1
// 注册终结器：obj 被 GC 回收时调用 cleanup
2
runtime.SetFinalizer(obj, func(o *MyResource) {
3
    o.Close() // 释放 native 资源
4
})

1
const cache = new Map();
2
const registry = new FinalizationRegistry((key) => {
3
    cache.delete(key); // 对象被回收后清理缓存条目
4
});
5

6
function getCached(key, loader) {
7
    if (cache.has(key)) {
8
        const ref = cache.get(key);
9
        const value = ref.deref(); // 检查弱引用是否还有效
10
        if (value !== undefined) return value;
11
    }
12
    const value = loader();
13
    cache.set(key, new WeakRef(value));
14
    registry.register(value, key); // 注册清理回调
15
    return value;
16
}

1
package weakcache
2

3
import (
4
    "runtime"
5
    "sync"
6
)
7

8
// Cache 基于 finalizer 的简易缓存
9
type Cache[K comparable, V any] struct {
10
    mu    sync.RWMutex
11
    items map[K]*entry[V]
12
}
13

14
type entry[V any] struct {
15
    value  V
16
    alive  bool
17
}
18

19
// New 创建缓存
20
func New[K comparable, V any]() *Cache[K, V] {
21
    return &Cache[K, V]{
22
        items: make(map[K]*entry[V]),
23
    }
24
}
25

26
// Set 添加缓存项，注册 finalizer 作为安全网
27
func (c *Cache[K, V]) Set(key K, value V) {
28
    c.mu.Lock()
29
    defer c.mu.Unlock()
30

31
    e := &entry[V]{value: value, alive: true}
32
    c.items[key] = e
33

34
    // finalizer 作为安全网：entry 不再被缓存引用时打印日志
35
    // 注意：finalizer 不能替代显式清理，只是兜底
36
    runtime.SetFinalizer(e, func(ee *entry[V]) {
37
        if ee.alive {
38
            // 如果还在 alive 状态被 GC 回收，说明缓存被意外清理
39
            // 生产环境应记录监控指标
40
        }
41
    })
42
}
43

44
// Get 获取缓存项
45
func (c *Cache[K, V]) Get(key K) (V, bool) {
46
    c.mu.RLock()
47
    defer c.mu.RUnlock()
48

49
    e, ok := c.items[key]
50
    if !ok || !e.alive {
51
        var zero V
52
        return zero, false
53
    }
54
    return e.value, true
55
}
56

57
// Remove 显式移除缓存项
58
func (c *Cache[K, V]) Remove(key K) {
59
    c.mu.Lock()
60
    defer c.mu.Unlock()
61

62
    if e, ok := c.items[key]; ok {
63
        e.alive = false
64
        runtime.SetFinalizer(e, nil) // 取消 finalizer
65
        delete(c.items, key)
66
    }
67
}

1
class ObjectCache<K, V extends object> {
2
  private cache = new Map<K, WeakRef<V>>();
3
  private registry: FinalizationRegistry<K>;
4

5
  constructor() {
6
    // 对象被 GC 回收时自动清理缓存条目
7
    this.registry = new FinalizationRegistry((key: K) => {
8
      const ref = this.cache.get(key);
9
      // 二次检查：对象可能已被重新缓存
10
      if (ref && ref.deref() === undefined) {
11
        this.cache.delete(key);
12
      }
13
    });
14
  }
15

16
  // 获取缓存对象
17
  get(key: K, loader: () => V): V {
18
    const ref = this.cache.get(key);
19
    if (ref) {
20
      const value = ref.deref();
21
      if (value !== undefined) return value;
22
      // 弱引用已失效，清理残留条目
23
      this.cache.delete(key);
24
    }
25

26
    // 加载并缓存
27
    const value = loader();
28
    this.cache.set(key, new WeakRef(value));
29
    this.registry.register(value, key);
30
    return value;
31
  }
32

33
  // 手动移除
34
  delete(key: K): void {
35
    this.cache.delete(key);
36
  }
37
}

1
interface ImageResource {
2
  width: number;
3
  height: number;
4
  data: Uint8Array;
5
}
6

7
const imageCache = new ObjectCache<string, ImageResource>();
8

9
// 首次加载
10
const img1 = imageCache.get("hero.png", () => loadImage("hero.png"));
11

12
// 后续获取直接返回缓存
13
const img2 = imageCache.get("hero.png", () => loadImage("hero.png"));
14
// img1 === img2，同一对象
15

16
// GC 回收后再次获取会重新加载
17
// （需要在没有其他强引用指向该 ImageResource 时）