• 后端
• 机器学习
• 物联网

Bolt 是一个用纯 Go 实现的嵌入式键值存储引擎，灵感源自 Howard Chu 的 LMDB 项目，目标是"无需 Postgres/MySQL 这类完整数据库服务器"的项目也能拥有简单、快速、可靠的持久化能力。本文以本仓库 vendor 目录中的 Bolt README（版本 1.2.1）为核心骨架，逐节讲解它的安装、事务、Bucket、游标迭代、备份、统计、只读模式、与其他数据库的对比及各项使用限制，并结合 FIND 室内定位框架（仓库根目录源码）真实调用 Bolt 的代码，给出可复制、可运行的实战示例与源码级原理佐证。读完你将掌握 Bolt 的完整 API 用法、事务语义和底层实现机制，并能在自己的 Go 项目中正确选型与规避陷阱。

一、Bolt 是什么：纯 Go 的嵌入式键值存储

Bolt 是一个直接嵌入应用程序进程的键值数据库：整个数据库就是一个磁盘上的单文件，没有独立的服务器进程，也不需要 SQL。它的 API 刻意保持小巧，"只关注 get value 和 set value"。作为底层存储组件，简单性是第一原则——这一设计哲学决定了它和关系型数据库、LSM 树存储引擎（如 LevelDB）有着本质差异。

从项目状态看，Bolt 已经稳定：API 固定、文件格式固定，并依靠完整单元测试覆盖与随机化黑盒测试（本仓库 vendor/github.com/boltdb/bolt 下存在大量*_test.go文件，如 db_test.go、simulation_test.go、quick_test.go）来保证数据库的一致性与线程安全。README 还说明它已被用于生产环境服务上 TB 级数据库（如 Shopify、Heroku 的 Bolt 支撑服务）——这属于原文档的官方陈述。

在 FIND 项目中，Bolt 以 vendor 方式静态内嵌，版本由 Gopkg.toml（第 25 行）与 Gopkg.lock（第 11 行）锁定，全仓库源码均通过github.com/boltdb/bolt导入路径调用。定位指纹、参数、MQTT 数据等全部持久化在按 group 命名的*.db单文件数据库里，例如 db.go 中groupExists直接检查group+".db"文件是否存在。

二、安装与打开数据库

2.1 安装：go get与 vendor 两种方式

原文档给出的安装方式是 Go 传统工具链：

$ go get github.com/boltdb/bolt/...

该命令会拉取库本身，并把bolt命令行工具安装到$GOBIN路径。在 FIND 这类使用旧版依赖管理（dep/Gopkg）的项目中，Bolt 被整体放进 vendor 目录，无需额外安装即可编译；boltCLI 的完整源码位于 vendor/github.com/boltdb/bolt/cmd/bolt/main.go。

bolt命令行工具支持以下子命令（见 main.go 的命令分发 switch）：

其中compact与 README "无法截断数据文件回收空间" 的限制直接互补——压缩到新文件后，空闲页不再保留。

2.2 打开数据库：bolt.Open与文件锁

Bolt 的顶层对象是DB，对应磁盘上的单个文件，代表数据的一个一致快照。打开数据库：

package main import ( "log" "github.com/boltdb/bolt" ) func main() { // 打开当前目录下的 my.db；若文件不存在会自动创建 db, err := bolt.Open("my.db", 0600, nil) if err != nil { log.Fatal(err) } defer db.Close() // ... }

重要并发约束：Bolt 会对数据文件加文件锁，因此同一时刻多个进程不能打开同一个数据库。打开一个已被别的进程占用的 Bolt 数据库会一直挂起，直到对方关闭。可通过Options.Timeout避免无限等待：

db, err := bolt.Open("my.db", 0600, &bolt.Options{Timeout: 1 * time.Second})

从源码看，Open的核心流程（vendor/github.com/boltdb/bolt/db.go）依次是：应用Options默认值 → 以O_RDWR/O_RDONLY打开文件 → 通过flock加排他锁（读写模式）或共享锁（只读模式）→ 若文件为空则调用init()初始化 meta 页 → 读取 meta 页确定页大小 →mmap内存映射数据文件 → 读入 freelist（空闲页链表）。超时等待加锁的实现位于平台相关文件，如 bolt_unix.go、bolt_windows.go 中的ErrTimeout。

FIND 项目中的打开方式与文档示例完全一致，例如 db.go：

db, err := bolt.Open(path.Join(RuntimeArgs.SourcePath, group+".db"), 0600, nil) if err != nil { log.Fatal(err) } defer db.Close()

Options结构体（db.go）除Timeout外还包括：

• NoGrowSync bool：跳过扩容时的 truncate 调用，仅在非 ext3/ext4 文件系统上安全；
• ReadOnly bool：以只读模式打开（UNIX 下用LOCK_SH | LOCK_NB加共享锁）；
• MmapFlags int：传给 mmap 的额外标志，Linux 2.6.23+ 可设为syscall.MAP_POPULATE做顺序预读；
• InitialMmapSize int：初始 mmap 字节数，若足够容纳数据库，读事务不会阻塞写事务；<=0表示初始映射为 0。

默认选项DefaultOptions（db.go）为Timeout: 0（无限等待）、NoGrowSync: false。

三、事务模型：单写多读 + 一致快照

Bolt同一时刻只允许一个读-写事务，但允许任意多个只读事务并发。每个事务都拥有"事务开始时数据"的一致视图（MVCC 快照）。README 明确强调：单个事务及其派生的对象（bucket、key）不是线程安全的，多 goroutine 操作数据时必须为每个 goroutine 各开一个事务，或用锁保证同一时刻只有一个 goroutine 访问；而从DB创建事务本身是线程安全的。

还有一个容易踩坑的死锁警告：只读事务与读写事务不应在同一 goroutine 中同时打开——因为读写事务需要周期性重新映射（re-map）数据文件，而只要有只读事务未关闭，mmap 写锁就拿不到，造成互相等待。

3.1 读写事务：DB.Update

err := db.Update(func(tx *bolt.Tx) error { // ... return nil })

闭包内看到的是数据库的一致视图；返回nil即提交事务，返回 error 即回滚。读写事务内允许所有数据库操作。务必检查返回值——磁盘故障可能导致事务未完成；闭包内返回的错误会原样传递出来。

3.2 只读事务：DB.View

err := db.View(func(tx *bolt.Tx) error { // ... return nil })

闭包内同样获得一致视图，但不允许任何修改操作，只能获取 bucket、读取 value、以及复制数据库（WriteTo）。FIND 项目中绝大多数查询都走db.View，如 api.go 在只读事务里用Cursor.Last()反向遍历fingerprints-track桶定位用户最近一次指纹。

3.3 批量事务：DB.Batch

每次DB.Update都要等磁盘提交写操作，开销不小。DB.Batch可以把多个更新合并：

err := db.Batch(func(tx *bolt.Tx) error { // ... return nil })

并发调用Batch时会被机会式地合并成更大的事务。只有多个 goroutine 同时调用时才有价值。代价是：若事务部分失败，Batch可能多次调用你传入的函数，因此该函数必须幂等，副作用只能在DB.Batch成功返回后生效。文档给出的反例是"不要在函数内打印消息，而应在闭包外层作用域设置变量"：

var id uint64 err := db.Batch(func(tx *bolt.Tx) error { // 找到桶内最后一个 key，按大端 uint64 解码、加一、再编码为新 key 写入 // ... id = newValue return nil }) if err != nil { return // ... } fmt.Println("Allocated ID %d", id)

3.4 手动管理事务：DB.Begin

View/Update本质上是DB.Begin的封装：自动开启事务、执行函数、出错时安全关闭事务——这是官方推荐用法。但有时需要手动控制，此时务必记得关闭事务：

// 开启可写事务 tx, err := db.Begin(true) if err != nil { return err } defer tx.Rollback() // 使用事务…… _, err := tx.CreateBucket([]byte("MyBucket")) if err != nil { return err } // 提交并检查错误 if err := tx.Commit(); err != nil { return err }

DB.Begin的第一个布尔参数表示事务是否可写。

源码佐证：Update（db.go）先Begin(true)，再注册defer兜底回滚，并给事务打上 "managed" 标记，防止闭包内手动 Commit/Rollback 引发 panic。底层beginTx与beginRWTx（db.go）分别依赖三把锁：metalock（保护 meta 页访问，读事务短暂持有）、mmaplock.RLock（只读事务持有，防止 mmap 被重映射）、rwlock（写事务独占，保证任意时刻只有一个 writer）。beginRWTx还会扫描已关闭的只读事务，把可回收的页归还给 freelist。

四、Bucket 与键值操作

4.1 Bucket 管理

Bucket 是数据库内键值对的集合，桶内所有 key 必须唯一。创建桶：

db.Update(func(tx *bolt.Tx) error { b, err := tx.CreateBucket([]byte("MyBucket")) if err != nil { return fmt.Errorf("create bucket: %s", err) } return nil })

推荐模式是打开数据库后，对所有顶层 bucket 调用tx.CreateBucketIfNotExists()，保证它们在未来事务中一定存在；删除桶用tx.DeleteBucket()。FIND 项目正是这个模式的忠实实践者：fingerprint.go 每次写入前都执行tx.CreateBucketIfNotExists([]byte(database))，mqtt.go 创建"mqtt"桶，parameters.go 创建"resources"桶。

4.2 Put / Get / Delete

写入键值对用Bucket.Put：

db.Update(func(tx *bolt.Tx) error { b := tx.Bucket([]byte("MyBucket")) err := b.Put([]byte("answer"), []byte("42")) return err })

读取用Bucket.Get：

db.View(func(tx *bolt.Tx) error { b := tx.Bucket([]byte("MyBucket")) v := b.Get([]byte("answer")) fmt.Printf("The answer is: %s\n", v) return nil })

Get不返回错误，因为它的操作"保证能成功"（除非系统级故障）：key 存在则返回其字节切片值，不存在则返回nil。注意：key 可以被设置为零长度值，这与"key 不存在"是两回事。删除用Bucket.Delete。

两个易错点：

• Get返回的值只在事务打开期间有效；要在事务外使用必须copy()到新字节切片；
• 同样适用于ForEach中拿到的 key/value。

FIND 的写入示例很好地演示了"时间戳作为 key"的数据组织：fingerprint.go 用strconv.FormatInt(res.Timestamp, 10)把 UnixNano 时间戳转成十进制字符串作 key，value 是经压缩序列化的指纹数据，天然按时间排序，便于游标按时间回溯。

4.3 自增整数：NextSequence

用Bucket.NextSequence()可以让 Bolt 维护一个单调递增序列，作为键值对的唯一标识。完整示例（原文档的CreateUser模式，含 8 字节大端编码辅助函数）：

// CreateUser saves u to the store. The new user ID is set on u once the data is persisted. func (s *Store) CreateUser(u *User) error { return s.db.Update(func(tx *bolt.Tx) error { // 获取 users 桶（应在 DB 首次打开时创建） b := tx.Bucket([]byte("users")) // 生成用户 ID；仅在 Tx 已关闭或不可写时返回错误， // 而 Update 调用中不会发生，因此忽略错误检查 id, _ := b.NextSequence() u.ID = int(id) // 把用户数据 marshal 成字节 buf, err := json.Marshal(u) if err != nil { return err } // 持久化到 users 桶 return b.Put(itob(u.ID), buf) }) } // itob 返回 v 的 8 字节大端表示 func itob(v int) []byte { b := make([]byte, 8) binary.BigEndian.PutUint64(b, uint64(v)) return b } type User struct { ID int // ... }

大端编码保证"ID 排序 == 字节序排序"，配合 Bolt 的有序 key 存储，天然支持按 ID 范围扫描。

五、迭代与扫描：Cursor 游标

Bolt 在桶内按键的字节序（byte-sorted）存储，因此顺序迭代极快。迭代使用Cursor：

db.View(func(tx *bolt.Tx) error { // 假设桶已存在且有 key b := tx.Bucket([]byte("MyBucket")) c := b.Cursor() for k, v := c.First(); k != nil; k, v = c.Next() { fmt.Printf("key=%s, value=%s\n", k, v) } return nil })

游标可定位到 key 列表中的任意位置，并一次一个地前后移动。可用函数：

First() Move to the first key. Last() Move to the last key. Seek() Move to a specific key. Next() Move to the next key. Prev() Move to the previous key.

每个函数的返回签名都是(key []byte, value []byte)。迭代到末尾后Next()返回nilkey。必须先通过First()、Last()或Seek()定位，再调用Next()/Prev()，否则会返回nilkey。还有一个重要语义：迭代中若 key 非nil而 value 为nil，说明该 key 指向的是子 bucket而非值，需用Bucket.Bucket()访问子桶。

5.1 前缀扫描

Seek()与bytes.HasPrefix组合即可按前缀迭代：

db.View(func(tx *bolt.Tx) error { // 假设桶已存在且有 key c := tx.Bucket([]byte("MyBucket")).Cursor() prefix := []byte("1234") for k, v := c.Seek(prefix); k != nil && bytes.HasPrefix(k, prefix); k, v = c.Next() { fmt.Printf("key=%s, value=%s\n", k, v) } return nil })

5.2 范围扫描

时间范围查询是典型场景：key 使用可排序的时间编码（如 RFC3339），就能查询某个日期区间：

db.View(func(tx *bolt.Tx) error { // 假设 Events 桶存在，key 是 RFC3339 编码的时间 c := tx.Bucket([]byte("Events")).Cursor() // 时间范围覆盖 90 年代 min := []byte("1990-01-01T00:00:00Z") max := []byte("2000-01-01T00:00:00Z") // 迭代整个 90 年代 for k, v := c.Seek(min); k != nil && bytes.Compare(k, max) <= 0; k, v = c.Next() { fmt.Printf("%s: %s\n", k, v) } return nil })

陷阱提示（原文档特别注明）：虽然 RFC3339 是可排序的，但 Go 的 RFC3339Nano 实现小数点后的位数不固定，因此不可排序，不能直接用于范围扫描 key。

5.3 ForEach

确定要遍历桶内全部 key 时用ForEach更直接：

db.View(func(tx *bolt.Tx) error { // 假设桶已存在且有 key b := tx.Bucket([]byte("MyBucket")) b.ForEach(func(k, v []byte) error { fmt.Printf("key=%s, value=%s\n", k, v) return nil }) return nil })

同样注意：ForEach的 key/value 仅在事务打开期间有效，事务外使用需copy()。

FIND 实战印证：游标遍历是 FIND 读取指纹的标配姿势。db.go 的getUsers在只读事务中用c.First()/c.Next()遍历fingerprints-track桶统计独立用户；api.go 用c.Last()/c.Prev()倒序遍历取最近指纹；backup.go 的dumpFingerprints同样用游标遍历fingerprints桶，逐条解压后写入dump-<group>/learning文件，实现离线备份导出。

六、嵌套 Bucket：多租户数据隔离

bucket 可以套 bucket，API 与 DB 层的桶管理 API 一致：

func (*Bucket) CreateBucket(key []byte) (*Bucket, error) func (*Bucket) CreateBucketIfNotExists(key []byte) (*Bucket, error) func (*Bucket) DeleteBucket(key []byte) error

多租户场景：根层桶是账号桶，账号桶内是账号序列（本身也是桶），账号序列桶内再按逻辑分组（Users、Notes 等）隔离数据。原文档给出完整实现：

// createUser 在给定账号中创建新用户。 func createUser(accountID int, u *User) error { // 开启事务。 tx, err := db.Begin(true) if err != nil { return err } defer tx.Rollback() // 获取账号的根桶（假设账号建立时已创建）。 root := tx.Bucket([]byte(strconv.FormatUint(accountID, 10))) // 创建 users 桶。 bkt, err := root.CreateBucketIfNotExists([]byte("USERS")) if err != nil { return err } // 生成新用户 ID。 userID, err := bkt.NextSequence() if err != nil { return err } u.ID = userID // 序列化并保存用户数据。 if buf, err := json.Marshal(u); err != nil { return err } else if err := bkt.Put([]byte(strconv.FormatUint(u.ID, 10)), buf); err != nil { return err } // 提交事务。 if err := tx.Commit(); err != nil { return err } return nil }

这个例子同时演示了手动事务管理、嵌套桶、NextSequence与Put的组合用法。FIND 项目中多个顶层桶（fingerprints、fingerprints-track、fingerprints-learn、mqtt、resources等）各自承载不同业务数据，正是"逻辑分组隔离"的体现。

七、数据库备份与统计

7.1 备份：单文件 + 热备份

Bolt 是单文件数据库，备份很简单。Tx.WriteTo把数据库的一致视图写入任意io.Writer；若在只读事务中调用，就是一次热备份，不会阻塞其他读和写。默认使用普通文件句柄（走操作系统页缓存）；数据库大于物理内存时的调优可参考Tx文档。CopyFile是写到另一个文件的便捷助手。

最常见的用法是走 HTTP，方便用 cURL 拉取备份：

func BackupHandleFunc(w http.ResponseWriter, req *http.Request) { err := db.View(func(tx *bolt.Tx) error { w.Header().Set("Content-Type", "application/octet-stream") w.Header().Set("Content-Disposition", `attachment; filename="my.db"`) w.Header().Set("Content-Length", strconv.Itoa(int(tx.Size()))) _, err := tx.WriteTo(w) return err }) if err != nil { http.Error(w, err.Error(), http.StatusInternalServerError) } }

然后一行命令完成备份：

$ curl http://localhost/backup > my.db

或在浏览器打开http://localhost/backup自动下载。FIND 的 backup.go 提供了另一种备份形态：把指纹数据解压成文本文件导出，便于离线分析与迁移。

7.2 统计：Stats与差分监控

数据库内部持续统计大量内部操作计数。对两个时间点各取一次快照，相减即可得到该时间段内执行了什么操作。比如启动一个 goroutine 每 10 秒记录一次：

go func() { // 抓取初始统计。 prev := db.Stats() for { // 等待 10s。 time.Sleep(10 * time.Second) // 抓取当前统计并与上次做差。 stats := db.Stats() diff := stats.Sub(&prev) // 把统计编码成 JSON 打印到 STDERR。 json.NewEncoder(os.Stderr).Encode(diff) // 保存本轮统计。 prev = stats } }()

Stats结构体（db.go）包含 freelist 统计（空闲页数FreePageN、待处理页数PendingPageN、空闲页分配字节FreeAlloc、freelist 占用字节FreelistInuse）与事务统计（累计读事务数TxN、当前打开的读事务数OpenTxN、全局进行中的TxStats）。Sub方法（db.go）专门用于计算两个时间点之间的差值。这类数据可以管道输送到 statsd 等监控服务，或提供一个做固定时长采样的 HTTP 端点。

八、只读模式与移动端使用

8.1 只读模式（共享锁）

需要创建一个可被多进程共享的只读 Bolt 数据库时，设置Options.ReadOnly：

db, err := bolt.Open("my.db", 0666, &bolt.Options{ReadOnly: true}) if err != nil { log.Fatal(err) }

只读模式使用共享锁：允许多个进程同时读，但会阻止任何进程以读写模式打开。若在只读模式下调用Update()或Begin(true)，会立即返回ErrDatabaseReadOnly（见 db.go）。

8.2 移动端（iOS/Android）

借助 gomobile 的绑定能力，Bolt 可以在移动设备上运行。做法是：定义一个持有*bolt.DB引用的包装结构体，构造器接收数据库文件路径。Android 与 iOS 都无需额外权限或清理逻辑：

func NewBoltDB(filepath string) *BoltDB { db, err := bolt.Open(filepath+"/demo.db", 0600, nil) if err != nil { log.Fatal(err) } return &BoltDB{db} } type BoltDB struct { db *bolt.DB // ... } func (b *BoltDB) Path() string { return b.db.Path() } func (b *BoltDB) Close() { b.db.Close() }

数据库逻辑定义为包装结构体上的方法。Android 侧（新系统用getNoBackupFilesDir()禁用云同步，老系统退回getFilesDir()）：

String path; if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.LOLLIPOP){ path = getNoBackupFilesDir().getAbsolutePath(); } else { path = getFilesDir().getAbsolutePath(); } Boltmobiledemo.BoltDB boltDB = Boltmobiledemo.NewBoltDB(path);

iOS 侧（放入 Library 目录并设置跳过 iCloud 备份属性）：

- (void)demo { NSString* path = [NSSearchPathForDirectoriesInDomains(NSLibraryDirectory, NSUserDomainMask, YES) objectAtIndex:0]; GoBoltmobiledemoBoltDB * demo = GoBoltmobiledemoNewBoltDB(path); [self addSkipBackupAttributeToItemAtPath:demo.path]; // 数据库逻辑写在这里 [demo close]; }

九、与其他数据库的对比

9.1 与 Postgres、MySQL 等关系型数据库

关系型数据库把数据组织成行，只能通过 SQL 访问，灵活性高，但要为 SQL 的解析与计划付出额外开销；Bolt 则全部按字节切片 key 访问，按键读写很快，但没有内置 join 能力。关系型数据库（SQLite 除外）大多是独立服务器，可让多台应用服务器连一个数据库实例，但需要网络序列化传输开销；Bolt 作为库打进应用进程，数据离应用更近，但限制了多进程访问。

9.2 与 LevelDB、RocksDB

LevelDB 及衍生品（RocksDB、HyperLevelDB）同样是内嵌库，但底层是LSM 树（日志结构合并树）：用预写日志 + 多层级有序 SSTable 文件优化随机写。Bolt 内部是B+tree + 单文件。两者各有取舍：

• 需要高随机写吞吐（>10,000 写/秒）或必须用机械硬盘时，LevelDB 更合适；
• 应用读多或做大量范围扫描时，Bolt 更合适；
• 关键差异：LevelDB 没有事务，只支持批量写和读快照，无法安全地做 compare-and-swap 类操作；Bolt 支持完全可串行化的 ACID 事务。

9.3 与 LMDB

Bolt 最初是 LMDB 的移植，架构上相似：都是 B+tree、都具备完全可串行化事务的 ACID 语义、都通过"单写多读"实现无锁 MVCC。两者后来产生分歧：LMDB 极致追求原始性能，甚至允许直接写等不安全操作；Bolt 更注重简单易用，拒绝任何可能让数据库进入损坏状态的操作，唯一的例外是DB.NoSync。API 上也有差异：LMDB 打开mdb_env时必须指定最大 mmap 大小，Bolt 自动处理 mmap 增量扩容；LMDB 用标志位重载 getter/setter，Bolt 把各种特例拆成独立函数。

十、使用限制与注意事项（Caveats & Limitations）

选对工具很重要，使用 Bolt 前必须了解以下约束（全部来自原文档，逐条继承）：

1. 适合读密集：顺序写也快，但随机写可能较慢，可用DB.Batch()或加预写日志缓解；
2. SSD 收益显著：B+tree 内部存在大量随机页访问，SSD 比机械盘提升明显；
3. 避免长读事务：Bolt 采用写时复制（copy-on-write），旧事务还引用旧页时，旧页无法被回收；
4. 返回的字节切片仅事务内有效：事务提交/回滚后，其指向的内存可能被新页复用或从虚拟内存解除映射，访问会触发unexpected fault addresspanic；
5. 独占写锁：数据库文件不能被多进程共享；
6. 小心Bucket.FillPercent：对随机插入的桶设置过高填充率会导致页利用率极差；
7. 尽量用较大的桶：小桶一旦超过页大小（通常 4KB）会造成页利用率低下；
8. 避免单事务批量灌入：新桶页要到事务提交才分裂，单事务向新桶随机插入超过 100,000 对键值不推荐；
9. 内存占用可能很高（属预期）：Bolt 使用内存映射文件，OS 尽可能缓存整个文件并按需释放，因此大库可能显示高内存占用；只要 mmap 能装进进程虚拟地址空间，Bolt 可处理远大于物理 RAM 的数据库，但在32 位系统上可能有问题；
10. 字节序相关：数据结构是内存映射的，数据文件与字节序绑定——不能把小端机器的 Bolt 文件拷到大端机器使用（现代 CPU 基本都是小端，多数用户无碍）；
11. 无法截断文件：受页布局限制，Bolt 不能把空闲页还给磁盘，而是在文件内维护空闲页链表供后续事务复用，因此删除大量数据不会在磁盘上回收空间（可用bolt compact压缩到新文件解决）。

十一、阅读源码的路线图

Bolt 作为一个嵌入式、可串行化、事务性的键值数据库，代码量很小（原文档称不足 3K 行），非常适合想了解数据库工作原理的人作为入门。原文档推荐从五个入口开始：

• Open()：初始化数据库引用——不存在则创建、获取排他锁、读取 meta 页、mmap 映射文件。实现在 db.go；
• DB.Begin()：按writable参数开启只读或读写事务，需要短暂持有 meta 锁跟踪打开的事务；读写事务通过rwlock保证唯一性。见 db.go；
• Bucket.Put()：校验参数后，用游标在 B+tree 上定位页与写入位置，然后把所在页及父页物化为内存中的 "nodes"，所有变更在读写事务期间发生、提交时落盘。实现在 bucket.go；
• Bucket.Get()：游标定位键值对的页与位置；只读事务下直接返回 mmap 文件的引用（零分配开销）；读写事务下可能引用 mmap 文件或内存节点值；
• Cursor：封装 B+tree 的页/节点遍历，可 seek 到指定 key、移动到首/尾、前后移动，向上/向下穿越 B+tree 对调用者透明。见 cursor.go；
• Tx.Commit()：把脏节点与空闲页列表转换成要写盘的页，分两阶段写：先写脏页并fsync()，再写递增事务 ID 的新 meta 页并再次fsync()。两阶段写保证崩溃时部分写入的数据页被忽略（指向它们的 meta 页从未写出），而部分写入的 meta 页因带校验和而失效。相关实现见 tx.go 与 db.go 中带checksum字段的 meta 结构与validate()校验逻辑。

十二、总结

Bolt 用单文件 + B+tree + MVCC 事务的组合，换来了嵌入式存储中最朴素的可靠性与可读性：API 小巧、事务语义完备（完全可串行化 ACID）、备份简单、统计透明。选型上它适合读密集、需要事务、数据规模在单机可控范围的应用；遇到高随机写吞吐需求选 LSM 系引擎，需要 SQL 与多进程共享则回到关系型数据库。在 FIND 项目中，它稳定承担了指纹、参数、MQTT 等全部持久化职责，源码中以db.View/db.Update+CreateBucketIfNotExists+Cursor构成的读写范式，正是本指南各章节 API 的真实生产化写照。若想深入数据库内核，本仓库 vendor/github.com/boltdb/bolt 的源码与测试（如 simulation_test.go 的随机化测试）是极佳的学习材料。

• 后端
• 机器学习
• 物联网