1
package freelist
2

3
// FreeList 固定大小槽位的空闲链表分配器
4
type FreeList struct {
5
    capacity int
6
    nextSlot int       // 下一个从未使用过的槽位
7
    free     []int     // 已释放的槽位栈
8
}
9

10
func NewFreeList(capacity int) *FreeList {
11
    return &FreeList{
12
        capacity: capacity,
13
        free:     nil,
14
    }
15
}
16

17
// Alloc 分配一个槽位，返回槽位索引
18
// 优先复用已释放的槽位（LIFO，缓存友好）
19
func (fl *FreeList) Alloc() (int, bool) {
20
    if len(fl.free) > 0 {
21
        // 从栈顶弹出最近释放的槽位
22
        slot := fl.free[len(fl.free)-1]
23
        fl.free = fl.free[:len(fl.free)-1]
24
        return slot, true
25
    }
26
    if fl.nextSlot >= fl.capacity {
27
        return 0, false // 容量耗尽
28
    }
29
    slot := fl.nextSlot
30
    fl.nextSlot++
31
    return slot, true
32
}
33

34
// Free 释放槽位，推入空闲栈
35
func (fl *FreeList) Free(slot int) {
36
    fl.free = append(fl.free, slot)
37
}
38

39
// Available 返回可用槽位数量
40
func (fl *FreeList) Available() int {
41
    return len(fl.free) + (fl.capacity - fl.nextSlot)
42
}
43

44
// Allocated 返回已分配的槽位数量
45
func (fl *FreeList) Allocated() int {
46
    return fl.nextSlot - len(fl.free)
47
}

1
class FreeList {
2
  private freeSlots: number[] = [];
3
  private nextSlot: number;
4

5
  constructor(private capacity: number) {
6
    this.nextSlot = 0;
7
  }
8

9
  // 分配槽位：优先复用已释放的
10
  alloc(): number | null {
11
    if (this.freeSlots.length > 0) {
12
      return this.freeSlots.pop()!;
13
    }
14
    if (this.nextSlot >= this.capacity) {
15
      return null; // 容量耗尽
16
    }
17
    return this.nextSlot++;
18
  }
19

20
  // 释放槽位：推入空闲栈顶
21
  free(slot: number): void {
22
    this.freeSlots.push(slot);
23
  }
24

25
  get available(): number {
26
    return this.freeSlots.length + (this.capacity - this.nextSlot);
27
  }
28

29
  get allocated(): number {
30
    return this.nextSlot - this.freeSlots.length;
31
  }
32
}
33

34
// 使用示例：实体管理器
35
const entitySlots = new FreeList(1000);
36
const entities: (object | null)[] = new Array(1000).fill(null);
37

38
function spawnEntity(data: object): number | null {
39
  const slot = entitySlots.alloc();
40
  if (slot === null) return null;
41
  entities[slot] = data;
42
  return slot;
43
}
44

45
function destroyEntity(slot: number): void {
46
  entities[slot] = null;
47
  entitySlots.free(slot);
48
}