1
// Disruptor RingBuffer.java 中的核心映射
2
E elementAt(long sequence) {
3
    return entries[BUFFER_PAD + (int)(sequence & indexMask)];
4
}

1
package ringbuffer
2

3
import "errors"
4

5
// RingBuffer 是固定大小的环形队列，容量为 2 的幂
6
type RingBuffer[T any] struct {
7
    buf  []T
8
    head uint64 // 读指针
9
    tail uint64 // 写指针
10
    mask uint64 // capacity - 1，用于位与取模
11
}
12

13
// New 创建容量为 2^k 的环形缓冲区
14
// 传入的 size 会向上取整到最近的 2 的幂
15
func New[T any](size uint64) *RingBuffer[T] {
16
    // 向上取整到 2 的幂
17
    cap := uint64(1)
18
    for cap < size {
19
        cap <<= 1
20
    }
21
    return &RingBuffer[T]{
22
        buf:  make([]T, cap),
23
        mask: cap - 1,
24
    }
25
}
26

27
// Enqueue 入队，满时返回错误
28
func (rb *RingBuffer[T]) Enqueue(val T) error {
29
    next := rb.tail + 1
30
    // 浪费一个槽位：tail+1 == head 表示满
31
    if next&rb.mask == rb.head&rb.mask {
32
        return errors.New("ring buffer: 已满")
33
    }
34
    rb.buf[rb.tail&rb.mask] = val
35
    rb.tail = next
36
    return nil
37
}
38

39
// Dequeue 出队，空时返回错误
40
func (rb *RingBuffer[T]) Dequeue() (T, error) {
41
    var zero T
42
    if rb.tail == rb.head {
43
        return zero, errors.New("ring buffer: 已空")
44
    }
45
    val := rb.buf[rb.head&rb.mask]
46
    rb.buf[rb.head&rb.mask] = zero // 避免引用残留，帮助 GC
47
    rb.head++
48
    return val, nil
49
}
50

51
// Len 返回当前元素个数
52
func (rb *RingBuffer[T]) Len() uint64 {
53
    // tail 和 head 不取模，差值就是元素数
54
    return rb.tail - rb.head
55
}

1
export class RingBuffer<T> {
2
  private buf: (T | undefined)[];
3
  private head = 0; // 读指针
4
  private tail = 0; // 写指针
5
  private count = 0; // 当前元素数
6
  private mask: number; // capacity - 1
7

8
  constructor(capacity: number) {
9
    // 向上取整到 2 的幂
10
    let cap = 1;
11
    while (cap < capacity) cap <<= 1;
12
    this.buf = new Array<T | undefined>(cap);
13
    this.mask = cap - 1;
14
  }
15

16
  /** 入队，满时返回 false */
17
  enqueue(val: T): boolean {
18
    if (this.count === this.buf.length) return false;
19
    this.buf[this.tail & this.mask] = val;
20
    this.tail++;
21
    this.count++;
22
    return true;
23
  }
24

25
  /** 出队，空时返回 undefined */
26
  dequeue(): T | undefined {
27
    if (this.count === 0) return undefined;
28
    const val = this.buf[this.head & this.mask];
29
    this.buf[this.head & this.mask] = undefined; // 释放引用
30
    this.head++;
31
    this.count--;
32
    return val;
33
  }
34

35
  /** 查看队首元素 */
36
  peek(): T | undefined {
37
    if (this.count === 0) return undefined;
38
    return this.buf[this.head & this.mask];
39
  }
40

41
  get length(): number {
42
    return this.count;
43
  }
44
}