btype 深度拆解：当 GJSON 作者决定在 Go 里造一个比 Rust 还快的 B 树

——基于 B 树的集合类型设计哲学、算法实现与生产级性能调优实战

一、引言：为什么 Go 开发者需要更好的集合类型？

在 Go 生态里，原生的 map[K]V 和 slice 几乎能覆盖 80% 的业务场景。但当你开始做有序遍历、范围查询、前缀搜索、高频写入的有序索引这类需求时，原生的 map 就开始暴露它的局限性：

1. 无序性：map 的遍历顺序是随机的，无法保证有序。
2. 范围查询 O(n)：要找 [a, b] 区间的键，只能遍历整个 map。
3. 没有原生集合运算：交集、并集、差集需要自己写循环。
4. 内存碎片：大量 map 操作会产生的内存分配碎片化。

Rust 的 std::collections 里有 BTreeMap、BTreeSet、BTreeMultiMap，支持有序操作。Go 社区也尝试过各种方案：第三方库 序列化和反序列化、golang-set、teris-io/bstream 等等，但要么功能残缺，要么性能拉胯。

2026 年 8 月，GJSON 和 SJSON 的作者（已知最流行的 Go JSON 解析库，数万 star 量）推出了一款新库 —— btype。根据官方基准测试，它不仅比 Go 原生实现快，在 B 树的核心操作上甚至比 Rust 的 std::collections 和 C++ STL 还要快。

本文将深入拆解这款库的设计哲学、核心实现原理、性能优化的工程细节，以及如何把它应用到真实的生产场景。

二、B 树基础：为什么 B 树在现代硬件上仍然是最优选择

2.1 B 树 vs 红黑树：磁盘友好 vs 内存友好的选择

大多数程序员对 B 树的印象停留在"数据库索引用的数据结构"，但实际上 B 树的优势在内存场景下依然成立：

现代 CPU 的 L1/L2/L3 缓存行大小通常是 64 字节。B 树的每个节点通常设计为多个缓存行的大小（比如 256 字节或 4096 字节），这意味着一次内存读取就能加载几十个键值对。相比之下，红黑树的每个节点只有几个指针和键值，缓存利用率极低。

2.2 B 树的阶（Order）与性能的关系

B 树的"阶"（通常记为 B 或 t）直接决定了节点容量：

最小键数: t-1
最大键数: 2t-1
最小子节点: t
最大子节点: 2t

阶越大，节点能容纳的键越多，树的高度越矮，内存访问次数越少。但阶太大也会有问题：单次查找需要在节点内做更多比较。

btype 的设计者经过实验，选择了一个动态调整的策略，根据键值对的大小自动计算最优阶。

2.3 B 树的写入路径：为什么 B 树写性能可以接近 O(log n)

B 树的插入和删除操作最坏情况是 O(log n) 的树高，但由于节点的分裂/合并是批量操作，实际性能比红黑树更好：

• 红黑树的插入：最多需要 2 次旋转 + 若干次重着色，每次操作可能触发多次树形调整
• B 树的插入：只在叶子节点层做分裂，一路向上最多影响 O(log n) 个节点，每个节点操作是连续的内存块写入

这就是 btype 声称比 Rust/C++ 更快的基础 —— 不是算法本身更优越，而是内存分配的局部性 + 批量写操作的组合优势。

三、btype 核心 API 设计：比 Rust 更符合直觉的接口

3.1 五种集合类型一览

btype 提供了 5 种核心集合类型：

// BMap — 有序键值映射，等价于 Rust 的 BTreeMap
btype.BMap[string, int]

// BSet — 有序集合，等价于 Rust 的 BTreeSet
btype.BSet[int]

// BTable — 表格结构，支持多列，类似数据库表
btype.BTable

// BQueue — 优先级队列
btype.BQueue[string]

// BStack — 栈（FILO）
btype.BStack[int]

3.2 BMap：最常用的有序 Map

package main

import (
    "fmt"
    "github.com/tidwall/btype"
)

func main() {
    // 创建 BMap，键类型 string，值类型 int
    m := btype.NewBMap[string, int]()

    // 插入键值对
    m.Set("alpha", 1)
    m.Set("beta", 2)
    m.Set("gamma", 3)
    m.Set("delta", 4)

    // 按插入顺序遍历（实际是字典序）
    m.Range(func(key string, value int) bool {
        fmt.Printf("%s: %d\n", key, value)
        return true // 返回 true 继续遍历，返回 false 停止
    })
    // 输出:
    // alpha: 1
    // beta: 2
    // delta: 4
    // gamma: 3

    // 范围查询：获取 [a, c) 区间的键值对
    m.RangeRange("a", "d", func(key string, value int) bool {
        fmt.Printf("%s: %d\n", key, value)
        return true
    })
    // 输出:
    // alpha: 1
    // beta: 2
    // delta: 4

    // 获取值
    val, ok := m.Get("beta")
    fmt.Printf("beta=%d, exists=%v\n", val, ok) // beta=2, exists=true

    // 最小/最大键
    minKey, minVal := m.Min()
    maxKey, maxVal := m.Max()
    fmt.Printf("min: %s=%d, max: %s=%d\n", minKey, minVal, maxKey, maxVal)

    // 前驱/后继
    prevKey, prevVal := m.Prev("gamma")
    nextKey, nextVal := m.Next("beta")
    fmt.Printf("prev(gamma)=%s=%d, next(beta)=%s=%d\n", prevKey, prevVal, nextKey, nextVal)

    // 删除
    deleted := m.Delete("beta")
    fmt.Printf("deleted beta=%v, new len=%d\n", deleted, m.Len())
}

注意一个关键设计：btype 的 Range 和 RangeRange 接受一个回调函数而非返回切片。这是一种迭代器模式的 Go 实现——避免了预先分配切片造成的内存浪费，也允许在遍历过程中提前终止。

3.3 BSet：高性能有序集合

package main

import (
    "fmt"
    "github.com/tidwall/btype"
)

func main() {
    s := btype.NewBSet[int]()

    s.Insert(5, 1, 9, 3, 7, 1) // 1 会去重
    fmt.Println("Set:", s.Items()) // [1 3 5 7 9] 升序

    // 集合运算
    other := btype.NewBSet[int]()
    other.Insert(2, 3, 4, 5)

    // 交集
    inter := s.Intersection(other)
    fmt.Println("交集:", inter.Items()) // [3 5]

    // 并集
    union := s.Union(other)
    fmt.Println("并集:", union.Items()) // [1 2 3 4 5 7 9]

    // 差集 (s - other)
    diff := s.Difference(other)
    fmt.Println("差集:", diff.Items()) // [1 7 9]

    // 对称差集
    symDiff := s.SymmetricDifference(other)
    fmt.Println("对称差集:", symDiff.Items()) // [1 2 4 7 9]

    // 子集判断
    sub := btype.NewBSet[int]()
    sub.Insert(1, 3, 5)
    fmt.Printf("%v ⊆ %v: %v\n", sub.Items(), s.Items(), sub.IsSubset(s)) // true
}

这个 API 设计和 Rust 的 BTreeSet 非常相似，但更符合 Go 习惯（Go 开发者更习惯用可变参数 Insert(elems...) 而非 iter::FromIter）。

3.4 BQueue：生产级优先级队列

package main

import (
    "fmt"
    "github.com/tidwall/btype"
)

// 带优先级的任务
type Task struct {
    Name     string
    Priority int // 数值越大优先级越高
}

// 实现 Less 方法供 BQueue 使用
func (t Task) Less(other btype.Item) bool {
    return t.Priority > other.(Task).Priority // 最大堆
}

func main() {
    q := btype.NewBQueue[Task]()

    q.Push(Task{Name: "紧急修复", Priority: 10})
    q.Push(Task{Name: "常规需求", Priority: 3})
    q.Push(Task{Name: "次要优化", Priority: 1})
    q.Push(Task{Name: "重要升级", Priority: 7})

    // 依次弹出最高优先级
    for !q.Empty() {
        task := q.Pop().(Task)
        fmt.Printf("处理: %s (优先级=%d)\n", task.Name, task.Priority)
    }
    // 输出顺序: 紧急修复 → 重要升级 → 常规需求 → 次要优化
}

3.5 BTable：表格结构的 B 树实现

BTable 是 btype 最独特的设计 —— 一个类数据库表的多列存储结构：

package main

import (
    "fmt"
    "github.com/tidwall/btype"
)

func main() {
    // 定义表结构
    columns := []btype.Column{
        {Name: "id", Type: btype.ColumnTypeInt},
        {Name: "name", Type: btype.ColumnTypeString},
        {Name: "score", Type: btype.ColumnTypeInt},
    }
    table := btype.NewBTable(columns...)

    // 插入行
    table.InsertRow(map[string]interface{}{
        "id":    1,
        "name":  "Alice",
        "score": 95,
    })
    table.InsertRow(map[string]interface{}{
        "id":    2,
        "name":  "Bob",
        "score": 88,
    })
    table.InsertRow(map[string]interface{}{
        "id":    3,
        "name":  "Charlie",
        "score": 72,
    })

    // 按列排序查询（score 升序）
    table.SortBy("score")
    table.Range(func(row btype.Row) bool {
        fmt.Printf("id=%d, name=%s, score=%d\n",
            row.GetInt("id"), row.GetString("name"), row.GetInt("score"))
        return true
    })

    // 范围筛选
    table.Filter("score >= 80", func(row btype.Row) bool {
        fmt.Printf("及格: %s=%d\n", row.GetString("name"), row.GetInt("score"))
        return true
    })
}

四、性能调优：btype 比 Rust/C++ 更快的工程秘密

4.1 节点设计：消除 GC 压力

Go 的 GC（垃圾回收器）是协作式的，但 STW（Stop The World）暂停在高吞吐量场景下是痛点。btype 的第一个工程优化是使用 sync.Pool 对象池来复用节点：

// btype 内部节点池的简化模型
var nodePool = sync.Pool{
    New: func() interface{} {
        return &btreeNode{
            entries: make([]btype.Entry, 0, 64), // 预分配容量 64
        }
    },
}

func newNode() *btreeNode {
    node := nodePool.Get().(*btreeNode)
    node.entries = node.entries[:0] // 重置，但不重新分配底层数组
    node.children = nil
    return node
}

func putNode(node *btreeNode) {
    // 放回池前清空子节点引用，避免内存泄漏
    node.children = nil
    nodePool.Put(node)
}

关键点：节点内 entries 的底层数组容量固定为 64，永远不重新分配。这消除了 Go GC 对节点分配的扫描压力。

4.2 批量分裂策略：减少锁竞争

在高并发写入场景下，B 树的分裂操作会变成瓶颈。btype 采用了 "批量分裂" 策略：

// 传统 B 树的插入：每次超过容量就立即分裂
func (n *btreeNode) insert(key btype.Key) {
    if len(n.entries) >= n.maxEntries {
        n.split() // 立即分裂
        // 继续向上递归
    }
    // 插入到合适位置
}

// btype 的批量分裂：延迟分裂，批量处理
func (n *btreeNode) insert(key btype.Key) {
    // 先尝试在当前节点内找空位（大多数情况有）
    if n.insertIntoExisting(key) {
        return
    }

    // 当前节点满了，延迟分裂
    // 先把新键标记为"待分裂"，累积到一定程度再统一处理
    n.pendingInsertions = append(n.pendingInsertions, key)

    // 只有当 pendingInsertions 超过阈值（比如 maxEntries 的 150%）
    // 才触发真正的分裂操作
    if len(n.pendingInsertions) > n.maxEntries*3/2 {
        n.flushPendingInsertions()
        n.rebalanceTree()
    }
}

这种延迟分裂 + 批量 flush 的策略，显著减少了树形调整的频率，也减少了锁竞争。

4.3 分支因子优化：基于键大小的自适应策略

B 树的阶不是固定值，而是根据键值对的大小动态计算的：

func calculateOrder(keySize, valueSize int) int {
    // 假设缓存行大小为 64 字节，节点尽量占满 4 个缓存行 (256 字节)
    cacheLineSize := 64
    targetNodeSize := cacheLineSize * 4 // 256 字节

    // 每个 entry 的固定开销：键指针 + 值指针 + 额外元数据
    fixedOverhead := 24 // 3 * 8 字节（两个指针 + 一个 length）

    // 子节点指针数组的大小（分裂后最多 2t 个）
    // 但在 B+ 树变体中，子节点指针存在父节点，这里简化计算
    entrySize := fixedOverhead + keySize + valueSize

    // 最优阶 = 节点容量 / 单个 entry 大小
    order := targetNodeSize / entrySize

    // 限制阶的范围（太大或太小都不好）
    if order < 4 {
        order = 4 // 最小阶 4
    }
    if order > 256 {
        order = 256 // 最大阶 256
    }

    return order
}

实验数据（官方基准测试）：

为什么随机插入反而比 Rust/C++ 快？ 因为 btype 的节点池 + 批量分裂策略减少了内存分配次数和 GC 压力，而 Rust/C++ 虽然没有 GC，但每次分配都是独立的 malloc()，系统调用开销累积下来反而更大。

4.4 SIMD 加速有序比较（进阶优化）

对于字符串键的场景，有序比较（key1 < key2）是热点操作。btype 使用了 SIMD 加速的字符串比较：

// 使用 Go 的 assembly 内联汇编调用 SIMD 指令
// 这段代码位于 runtime/asm_amd64.s，实际调用 CPU 的 SIMD 比较指令

//go:build amd64
// +build amd64

#include "textflag.h"

// hasPrefixSIMD 使用 SIMD 指令批量检查多个字节
// 比较逻辑：对齐到 16 字节边界，然后以 16 字节为单位批量比较
TEXT ·compareStringSIMD(SB), NOSPLIT, $0-48
    MOVQ  a_base+0(FP), DI   // 字符串 A 的指针
    MOVQ  a_len+8(FP), SI    // 字符串 A 的长度
    MOVQ  b_base+24(FP), DX  // 字符串 B 的指针
    MOVQ  b_len+32(FP), CX   // 字符串 B 的长度
    MOVQ  CX, BX             // BX = min(lenA, lenB)

    // 对齐到 16 字节边界
    ANDQ  $^15, BX           // BX = (minLen / 16) * 16

    // SIMD 批量比较（16 字节为一组）
loop:
    CMPQ  BX, $0
    JEQ   remainder          // 比较完了，处理剩余字节

    // 加载 16 字节到 XMM 寄存器
    MOVDQU (DI)(BX*1), X0   // A[i..i+15]
    MOVDQU (DX)(BX*1), X1   // B[i..i+15]

    // 使用 PCMPISTRI 做带符号整数比较
    // 结果存于 CX：第一个不同字节的偏移
    PCMPISTRI X0, X1, $0    // 相等性比较模式

    JC    mismatch          // CF=1 表示找到不同字节

    SUBQ  $16, BX
    JMP   loop

remainder:
    // 处理剩余 0~15 字节（普通字节比较）
    MOVQ  SI, BX             // 剩余字节数
remainder_loop:
    CMPQ  BX, $0
    JEQ   equal
    MOVB  (DI)(BX*1), AL
    CMPB  (DX)(BX*1), AL
    JNE   mismatch
    DECQ  BX
    JMP   remainder_loop

equal:
    XORQ  AX, AX             // 返回 0（相等）
    RET

mismatch:
    MOVQ  $1, AX             // 返回 1（不等）
    RET

这个 SIMD 优化对长字符串键的场景（URL、JSON path、文件路径）效果显著，单次比较从 O(n) 降到了 O(n/16)。

五、生产实战：从缓存到分布式 ID 分配器

5.1 场景一：高性能 LRU 缓存（取代 go-lru）

package cache

import (
    "github.com/tidwall/btype"
    "sync"
    "time"
)

// BTreeLRU 基于 btype 的 LRU 缓存
// 相比 go-lru 的切片实现，有序遍历可以更快找到最久未使用的条目
type BTreeLRU[K comparable, V any] struct {
    maxSize int
    tree    *btype.BMap[K, *cacheEntry[V]]
    mu      sync.RWMutex
}

type cacheEntry[V any] struct {
    value       V
    accessTime  int64 // 纳秒时间戳
}

func NewBTreeLRU[K comparable, V any](maxSize int) *BTreeLRU[K, V] {
    return &BTreeLRU[K, V]{
        maxSize: maxSize,
        tree:    btype.NewBMap[K, *cacheEntry[V]](),
    }
}

func (c *BTreeLRU[K, V]) Get(key K) (V, bool) {
    c.mu.Lock()
    defer c.mu.Unlock()

    entry, ok := c.tree.Get(key)
    if !ok {
        var zero V
        return zero, false
    }

    // 更新访问时间
    entry.accessTime = time.Now().UnixNano()
    return entry.value, true
}

func (c *BTreeLRU[K, V]) Put(key K, value V) {
    c.mu.Lock()
    defer c.mu.Unlock()

    if c.tree.Len() >= c.maxSize {
        // 淘汰最久未使用的条目（访问时间最小的）
        minKey, _ := c.tree.Min()
        c.tree.Delete(minKey)
    }

    c.tree.Set(key, &cacheEntry[V]{
        value:      value,
        accessTime: time.Now().UnixNano(),
    })
}

// RangeOldest 返回所有条目，按最久未使用排序（供调试）
func (c *BTreeLRU[K, V]) RangeOldest(fn func(key K, value V)) {
    c.mu.RLock()
    defer c.mu.RUnlock()

    c.tree.Range(func(key K, entry *cacheEntry[V]) bool {
        fn(key, entry.value)
        return true
    })
}

5.2 场景二：分布式 ID 分配器（基于有序区间的批量预分配）

package idgen

import (
    "github.com/tidwall/btype"
    "sync/atomic"
)

// RangeAllocator 基于 btype 的分布式 ID 区间分配器
// 用于：分库分表 Shard Key 分配、Redis Cluster Slot 分配、任务队列分区
type RangeAllocator struct {
    // 每个区间：[start, end)，已分配
    allocated *btype.BMap[int64, int64]
    // 全局最大已分配 ID
    maxID    atomic.Int64
    chunkSize int64
}

func NewRangeAllocator(chunkSize int64) *RangeAllocator {
    return &RangeAllocator{
        allocated: btype.NewBMap[int64, int64](),
        chunkSize:  chunkSize,
    }
}

// Allocate 申请一个连续的 ID 区间
// 返回区间 [start, end)
func (ra *RangeAllocator) Allocate(count int64) (start, end int64) {
    currentMax := ra.maxID.Load()
    start = currentMax
    end = start + count*ra.chunkSize

    // 以 chunkSize 为单位记录已分配区间
    for i := int64(0); i < count; i++ {
        chunkStart := start + i*ra.chunkSize
        ra.allocated.Set(chunkStart, chunkStart+ra.chunkSize)
    }

    ra.maxID.Store(end)
    return start, end
}

// Reclaim 归还一个未用完的区间（用于节点下线）
func (ra *RangeAllocator) Reclaim(start, end int64) {
    // 归还区间，合并相邻区间（利用 BTree 的有序性）
    ra.allocated.Delete(start)
    // 检查是否能与前后区间合并
    if prevStart, prevEnd := ra.allocated.Prev(start); prevEnd == start {
        // 与前一个区间合并
        newStart := prevStart
        ra.allocated.Delete(prevStart)
        ra.allocated.Set(newStart, end)
        start = newStart
    }
    if nextStart, nextEnd := ra.allocated.Next(start); nextStart == end {
        // 与后一个区间合并
        ra.allocated.Delete(nextStart)
        ra.allocated.Set(start, nextEnd)
    }
}

// AllocatedRanges 返回所有已分配区间（用于监控和调试）
func (ra *RangeAllocator) AllocatedRanges() [][2]int64 {
    var ranges [][2]int64
    ra.allocated.Range(func(start, end int64) bool {
        ranges = append(ranges, [2]int64{start, end})
        return true
    })
    return ranges
}

5.3 场景三：带版本控制的配置中心（利用 BTree 的版本快照）

package config

import (
    "github.com/tidwall/btype"
    "time"
)

// VersionedConfig 带版本控制的配置存储
// 利用 BTree 的有序性实现配置的热升级和回滚
type VersionedConfig struct {
    versions *btype.BMap[string, *ConfigVersion]
    current  atomic.Int64
}

type ConfigVersion struct {
    Version int64
    Config  map[string]string
    Created time.Time
    Tags    []string
}

func NewVersionedConfig() *VersionedConfig {
    return &VersionedConfig{
        versions: btype.NewBMap[string, *ConfigVersion](),
    }
}

// Commit 提交新版本配置
func (vc *VersionedConfig) Commit(config map[string]string, tags ...string) int64 {
    version := vc.current.Add(1)
    key := formatVersionKey(version)

    vc.versions.Set(key, &ConfigVersion{
        Version: version,
        Config:  config,
        Created: time.Now(),
        Tags:    tags,
    })

    return version
}

// GetVersion 获取指定版本
func (vc *VersionedConfig) GetVersion(version int64) (*ConfigVersion, bool) {
    key := formatVersionKey(version)
    return vc.versions.Get(key)
}

// Rollback 回滚到指定版本（实际上是复制旧版本为新版本）
func (vc *VersionedConfig) Rollback(version int64) (int64, bool) {
    target, ok := vc.versions.Get(formatVersionKey(version))
    if !ok {
        return 0, false
    }

    // 创建新版本，内容等于旧版本
    return vc.Commit(target.Config, "rollback:"+formatVersionKey(version)), true
}

// RangeByTag 查询带有特定标签的版本历史
func (vc *VersionedConfig) RangeByTag(tag string, fn func(*ConfigVersion) bool) {
    vc.versions.Range(func(key string, v *ConfigVersion) bool {
        for _, t := range v.Tags {
            if t == tag {
                return fn(v)
            }
        }
        return true
    })
}

func formatVersionKey(version int64) string {
    return time.Unix(0, version).UTC().Format("20060102150405.000000")
}

六、避坑指南：btype 的局限性与使用边界

btype 不是银弹，以下场景不适合使用：

6.1 小数据量（< 1000 条）

对于 1000 条以内的数据，原生 map + sort.Slice 的组合反而更快，因为：

• map 的查找是 O(1) 常数时间
• sort.Slice 对小数据集的排序是高度优化的
• btype 的树形结构开销在小数据量下不划算

经验法则：数据量 > 5000 条且需要有序操作时，考虑 btype。

6.2 极端写入吞吐量场景

btype 的批量分裂策略在高并发随机写入场景下可能造成写入延迟毛刺（batch flush 时一次性停顿）。如果你的业务是严格延迟敏感的（比如实时交易系统），可以考虑：

• 使用分片：多个 btype 实例，按 key hash 分片
• 或者改用 github.com/cockroachdb/cockroach/pkg/util/bintool.Comparable 这类 LSM-Tree 实现

6.3 键值过大（> 64KB）

btype 的节点设计假设键值对能放入节点。如果你的值经常 > 64KB，B 树节点会退化为单个键值对，失去 B 树的树形优势。这种场景下建议用对象存储或 LSM-Tree（如 badger 或 pebble）。

6.4 没有内置持久化

btype 是一个纯内存数据结构，不支持 WAL（Write-Ahead Log）或 AOF。如果需要持久化，必须自己实现：

// 简单的事务日志方案
type PersistedBMap[K, V comparable] struct {
    tree  *btype.BMap[K, V]
    wal   *os.File // Write-Ahead Log
}

func (p *PersistedBMap[K, V]) Set(key K, value V) {
    // 写入 WAL
    p.wal.WriteString(fmt.Sprintf("SET %v %v\n", key, value))
    // 内存更新
    p.tree.Set(key, value)
}

七、基准测试与竞品对比

7.1 官方基准测试结果（Mac M3 Pro, Go 1.24）

goos: darwin
goarch: arm64
cpu: Apple M3 Pro
BenchmarkBMapInsertSeq-12         1000000    1.2 ns/op    // 顺序插入
BenchmarkBMapInsertRand-12          500000    3.5 ns/op    // 随机插入
BenchmarkBMapGet-12                2000000    0.8 ns/op    // 单点查询
BenchmarkBMapRange-12               100000   12.1 ns/op    // 范围遍历（每元素）
BenchmarkBSetIntersection-12         10000  115.3 ns/op    // 交集
BenchmarkBQueuePush-12              500000    2.1 ns/op    // 入队
BenchmarkBQueuePop-12             1000000    1.5 ns/op    // 出队

// 对比 Rust BTreeMap (release mode)
Rust BTreeMap InsertRand-1         300000    4.8 ns/op    // Rust 随机插入
Rust BTreeMap Get-1               1000000    1.1 ns/op    // Rust 单点查询

7.2 与竞品的横向对比

八、总结与展望

btype 解决了什么问题

1. Go 生态缺少高质量有序集合库：填补了 Go 在 BTreeMap/BTreeSet 上的空白
2. 比 Rust/C++ 更快的实现：通过 sync.Pool 消除 GC 压力、SIMD 优化、批量分裂策略
3. 比 go-lru 更有序：不仅能做 LRU，还支持有序遍历、范围查询、集合运算
4. GJSON 作者背书：作者以极致性能优化著称（buntdb、SJSON 等），btype 继承了同样的工程哲学

什么时候用 btype

• ✅ 需要有序遍历（如：排名系统、时间线数据）
• ✅ 需要范围查询（如：区间统计、IP 黑名单）
• ✅ 需要集合运算（如：标签交集、权限判断）
• ✅ 高频读取、低频写入的有序缓存（如：热点数据缓存）
• ✅ 分布式 ID 分配、区间管理

什么时候不用 btype

• ❌ 数据量 < 5000 且不需要有序操作（原生 map 更简单）
• ❌ 严格延迟敏感的极端写入场景（考虑 LSM-Tree）
• ❌ 需要持久化（需要自己实现 WAL）

未来展望

btype 目前（v0.1.x）还是早期版本，几个值得关注的方向：

• 并发安全的 ConcurrentBMap：基于 sharding 的并发读实现
• 持久化层：btype.PebbleStore / btype.BadgerStore 集成
• 更丰富的索引支持：复合索引、多维查询
• WebAssembly 适配：btype-wasm 分支，让前端也能用到 B 树

GitHub 地址：https://github.com/tidwall/btype
官方文档：https://pkg.go.dev/github.com/tidwall/btype

参考资料

1. Tidwall GJSON - https://github.com/tidwall/gjson
2. Golang 技术周刊 2026 第 20 周 - https://blog.csdn.net/xiaohui_hubei/article/details/161571206
3. B-Tree 原始论文 - Bayer, R. & McCreight, E. (1972). "Organization and Maintenance of Large Ordered Indices"
4. Go sync.Pool 文档 - https://pkg.go.dev/sync#Pool
5. Rust std::collections - https://doc.rust-lang.org/std/collections/