1
package refcount
2

3
import "sync"
4

5
// RefCounted 引用计数的共享资源
6
type RefCounted[T any] struct {
7
    mu      sync.Mutex
8
    value   T
9
    count   int
10
    cleanup func(T)
11
}
12

13
// NewRefCounted 创建一个引用计数的资源
14
func NewRefCounted[T any](value T, cleanup func(T)) *RefCounted[T] {
15
    return &RefCounted[T]{
16
        value:   value,
17
        count:   1,
18
        cleanup: cleanup,
19
    }
20
}
21

22
// Clone 增加引用计数，返回同一指针
23
func (rc *RefCounted[T]) Clone() *RefCounted[T] {
24
    rc.mu.Lock()
25
    defer rc.mu.Unlock()
26
    rc.count++
27
    return rc
28
}
29

30
// Drop 减少引用计数，归零时触发清理
31
func (rc *RefCounted[T]) Drop() {
32
    rc.mu.Lock()
33
    defer rc.mu.Unlock()
34
    rc.count--
35
    if rc.count == 0 && rc.cleanup != nil {
36
        rc.cleanup(rc.value)
37
    }
38
}
39

40
// Count 返回当前引用计数
41
func (rc *RefCounted[T]) Count() int {
42
    rc.mu.Lock()
43
    defer rc.mu.Unlock()
44
    return rc.count
45
}

1
func processFile(path string) {
2
    f, _ := os.Open(path)
3
    // 创建引用计数的文件句柄
4
    handle := refcount.NewRefCounted(f, func(file *os.File) {
5
        file.Close() // 最后一个引用释放时关闭文件
6
        log.Println("file closed:", path)
7
    })
8

9
    // 传递给多个处理函数
10
    h1 := handle.Clone()
11
    h2 := handle.Clone()
12

13
    go func() {
14
        defer h1.Drop()
15
        // 读取文件...
16
    }()
17

18
    go func() {
19
        defer h2.Drop()
20
        // 读取文件...
21
    }()
22

23
    handle.Drop() // 主引用释放
24
    // 文件在最后一个 Drop() 时才真正关闭
25
}

1
type CleanupFn<T> = (value: T) => void;
2

3
interface RefCountedInner<T> {
4
  value: T;
5
  count: number;
6
  dropped: boolean;
7
  cleanup: CleanupFn<T>;
8
}
9

10
class RefCounted<T> {
11
  private inner: RefCountedInner<T>;
12
  private owned: boolean;
13

14
  constructor(value: T, cleanup: CleanupFn<T>) {
15
    this.inner = { value, count: 1, dropped: false, cleanup };
16
    this.owned = true;
17
  }
18

19
  // 创建新的共享引用
20
  clone(): RefCounted<T> {
21
    if (!this.owned) throw new Error("Cannot clone a dropped reference");
22
    this.inner.count++;
23
    const cloned = Object.create(RefCounted.prototype) as RefCounted<T>;
24
    cloned.inner = this.inner;
25
    cloned.owned = true;
26
    return cloned;
27
  }
28

29
  // 释放引用，归零时触发清理
30
  drop(): void {
31
    if (!this.owned) return; // 双重 drop 是空操作
32
    this.owned = false;
33
    this.inner.count--;
34
    if (this.inner.count === 0 && !this.inner.dropped) {
35
      this.inner.dropped = true;
36
      this.inner.cleanup(this.inner.value);
37
    }
38
  }
39

40
  refCount(): number {
41
    return this.inner.count;
42
  }
43

44
  value(): T {
45
    if (!this.owned) throw new Error("Reference has been dropped");
46
    return this.inner.value;
47
  }
48
}