Go / 系统课时
写一个并发安全的任务仓库
写一个并发安全的任务仓库
这一课把任务数据从普通 map 整理成可并发调用的仓库:读操作允许并行,新增、更新和删除互斥执行;上层还能用 errors.Is 稳定判断资源不存在或重复创建,而不是解析错误字符串。
学习目标
- 用
sync.RWMutex保护共享map,区分读锁与写锁。 - 实现任务的新增、查询、更新、删除,并让不存在错误可被上层判断。
- 用 Go race detector 验证并发访问没有数据竞争。
用 RWMutex 守住共享 map
Go 的普通 map 不能在没有同步的情况下被并发读写。仓库把 sync.RWMutex 和 map[string]Task 放在同一个结构体中:Get、Len 使用 RLock,Create、Update、Delete 使用独占的 Lock。锁只覆盖一次仓库操作,不把锁暴露给调用方。

这里把 Task 作为值存入 map,因此 Get 返回的是结构体副本,调用方不能绕过锁直接改仓库中的 Done。如果以后给 Task 增加 []string、map 或指针字段,要额外复制这些可变引用,不能只依赖结构体的浅拷贝。
实现 CRUD 与可判断错误
把下面保存为 main.go,使用 Go 1.20+ 即可运行。ErrNotFound 和 ErrAlreadyExists 是哨兵错误;服务层或 HTTP 层应使用 errors.Is(err, ErrNotFound) 判断,不要比较 err.Error() 文本。
package main
import (
"errors"
"fmt"
"sync"
)
// Sentinel errors let HTTP or service layers branch with errors.Is.
var (
ErrNotFound = errors.New("task not found")
ErrAlreadyExists = errors.New("task already exists")
)
type Task struct {
ID string
Title string
Done bool
}
type Repository struct {
// mu protects every access to tasks; never touch the map without this lock.
mu sync.RWMutex
tasks map[string]Task
}
func NewRepository() *Repository {
return &Repository{tasks: make(map[string]Task)}
}
func (r *Repository) Create(task Task) error {
r.mu.Lock()
defer r.mu.Unlock()
if _, exists := r.tasks[task.ID]; exists {
return ErrAlreadyExists
}
r.tasks[task.ID] = task
return nil
}
func (r *Repository) Get(id string) (Task, error) {
// Multiple readers may proceed together because Task is stored by value.
r.mu.RLock()
defer r.mu.RUnlock()
task, ok := r.tasks[id]
if !ok {
return Task{}, ErrNotFound
}
return task, nil
}
func (r *Repository) Update(id string, next Task) (Task, error) {
// Keep existence check and replacement in one exclusive critical section.
r.mu.Lock()
defer r.mu.Unlock()
if _, ok := r.tasks[id]; !ok {
return Task{}, ErrNotFound
}
next.ID = id
r.tasks[id] = next
return next, nil
}
func (r *Repository) Delete(id string) error {
r.mu.Lock()
defer r.mu.Unlock()
if _, ok := r.tasks[id]; !ok {
return ErrNotFound
}
delete(r.tasks, id)
return nil
}
func (r *Repository) Len() int {
r.mu.RLock()
defer r.mu.RUnlock()
return len(r.tasks)
}
func main() {
repo := NewRepository()
_ = repo.Create(Task{ID: "t1", Title: "write docs"})
task, _ := repo.Get("t1")
fmt.Printf("created=%s done=%v\n", task.Title, task.Done)
updated, _ := repo.Update("t1", Task{Title: "write docs", Done: true})
fmt.Printf("updated=%s done=%v\n", updated.Title, updated.Done)
err := repo.Delete("missing")
fmt.Printf("missing=%v\n", errors.Is(err, ErrNotFound))
_ = repo.Create(Task{ID: "a", Title: "A"})
_ = repo.Create(Task{ID: "b", Title: "B"})
// Concurrent reads and writes should stay clean under the race detector.
var wg sync.WaitGroup
for i := 0; i < 100; i++ {
i := i
wg.Add(1)
go func() {
defer wg.Done()
id := "a"
if i%2 == 1 {
id = "b"
}
_, _ = repo.Get(id)
_, _ = repo.Update(id, Task{Title: fmt.Sprintf("worker-%d", i), Done: i%3 == 0})
}()
}
wg.Wait()
_ = repo.Delete("t1")
_, err = repo.Get("t1")
fmt.Printf("after-delete-not-found=%v\n", errors.Is(err, ErrNotFound))
fmt.Printf("remaining=%d\n", repo.Len())
}预期结果:运行 go run -race main.go 后会得到下面的业务输出,并且 race detector 不应额外打印 DATA RACE 报告。
created=write docs done=false
updated=write docs done=true
missing=true
after-delete-not-found=true
remaining=2Update 中“检查是否存在”和“写回新值”必须处于同一个写锁临界区。如果先解锁再写,两个并发请求会在检查和修改之间插入,重新引入竞态。defer r.mu.Unlock() 放在成功加锁之后,可以覆盖正常返回和错误返回两条路径。
选择锁粒度并检查边界
当前仓库把单次 CRUD 作为最小原子操作,这对内存任务 API 已经足够。不要在持锁期间执行 HTTP 请求、磁盘 I/O 或长时间计算;这些操作会把其他请求一起堵在仓库门口。
| 场景 | 做法 | 原因 |
|---|---|---|
| 只读取一个任务 | RLock / RUnlock |
多个读者可并行 |
| 新增、更新、删除 | Lock / Unlock |
map 写入必须互斥 |
| “读后再改”必须不可分割 | 整段放在一次 Lock 内 |
避免检查与写入之间被插队 |
| 返回包含 slice/map 的任务 | 在锁内做深拷贝后返回 | 避免调用方在锁外修改共享底层数据 |
如果业务开始需要“任务 A 更新成功后再写任务 B”这类跨记录事务,单个 map 锁虽然仍然线程安全,但并不自动提供业务级回滚。此时应把原子操作设计在仓库方法边界内,或迁移到支持事务的持久化存储。