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。锁只覆盖一次仓库操作,不把锁暴露给调用方。

并发读写通过 RWMutex 访问任务 map

这里把 Task 作为值存入 map,因此 Get 返回的是结构体副本,调用方不能绕过锁直接改仓库中的 Done。如果以后给 Task 增加 []string、map 或指针字段,要额外复制这些可变引用,不能只依赖结构体的浅拷贝。

实现 CRUD 与可判断错误

把下面保存为 main.go,使用 Go 1.20+ 即可运行。ErrNotFound 和 ErrAlreadyExists 是哨兵错误;服务层或 HTTP 层应使用 errors.Is(err, ErrNotFound) 判断,不要比较 err.Error() 文本。

go
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 报告。

text
created=write docs done=false
updated=write docs done=true
missing=true
after-delete-not-found=true
remaining=2

Update 中“检查是否存在”和“写回新值”必须处于同一个写锁临界区。如果先解锁再写,两个并发请求会在检查和修改之间插入,重新引入竞态。defer r.mu.Unlock() 放在成功加锁之后,可以覆盖正常返回和错误返回两条路径。

选择锁粒度并检查边界

当前仓库把单次 CRUD 作为最小原子操作,这对内存任务 API 已经足够。不要在持锁期间执行 HTTP 请求、磁盘 I/O 或长时间计算;这些操作会把其他请求一起堵在仓库门口。

场景 做法 原因
只读取一个任务 RLock / RUnlock 多个读者可并行
新增、更新、删除 Lock / Unlock map 写入必须互斥
“读后再改”必须不可分割 整段放在一次 Lock 内 避免检查与写入之间被插队
返回包含 slice/map 的任务 在锁内做深拷贝后返回 避免调用方在锁外修改共享底层数据

如果业务开始需要“任务 A 更新成功后再写任务 B”这类跨记录事务,单个 map 锁虽然仍然线程安全,但并不自动提供业务级回滚。此时应把原子操作设计在仓库方法边界内,或迁移到支持事务的持久化存储。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

写一个并发安全的任务仓库

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通