解决使用Go语言时阅读缓存DIY书籍时可能遇到的线程安全问题

学习Golang要努力，但是不要急！今天的这篇文章《解决使用Go语言时阅读缓存DIY书籍时可能遇到的线程安全问题》将会介绍到等等知识点，如果你想深入学习Golang，可以关注我！我会持续更新相关文章的，希望对大家都能有所帮助！

我正在读一本教我如何编写像 redis 这样的简单缓存的书。

为了实现分布式哈希，项目必须进行密钥迁移，这需要迭代器。我认为可能存在一些问题。

他的书上讲了迭代一个map，但是迭代时，读锁的持有不是连续的。原因是试图不影响主缓存进程。我相信一定存在线程安全问题，因为主缓存线程仍在写入map。我写了一个演示，但不确定。

//book code
type inMemoryScanner struct {
    pair
    pair Chan *pair
    closeCh chan struct{}
}

func (c *inMemoryCache) NewScanner() Scanner {
    pairCh := make(chan *pair)
    closeCh := make(chan struct{})
    go func() {
        defer close(pairCh)
        c.mutex.RLock()
        //the c.c is book's map
        for k, v := range c.c {
            c.mutex.RUnlock()
            select {
            case <-closeCh:
                return
            case pairCh <- &pair{k, v}:
            }
            c.mutex.RLock()
        }
        c.mutex.RUnLock()
     }
     return &inMemoryScanner{pair{}, pairCh, closeCh}
}
//my demo
func main()  {
    testMap := make(map[string]string)
    mutex := sync.RWMutex{}
    for i := 0; i < 64; i ++ {
        mutex.Lock()
        testMap[uuid.New().String()] = uuid.New().String()
        mutex.Unlock()
        fmt.Println("Write")
    }
    go func() {
        for {
            mutex.Lock()
            testMap[uuid.New().String()] = uuid.New().String()
            time.Sleep(100 * time.Millisecond)
            mutex.Unlock()
            fmt.Println("Write")
        }
    } ()
    for k, v := range testMap {
        mutex.RLock()
        fmt.Println("k" + k + "v" + v)
        mutex.RUnlock()
        time.Sleep(100 * time.Millisecond)
    }
}

在我的演示中，“写入”和地图的结果数量不相等！而且我相信，在现实项目中，重新平衡不可能是一次，必须有持续的后台工作，不是吗？

解决方案

您正在进行数据竞赛。您的结果未定义。

简化代码以便其编译和运行，

package main

import (
    "sync"
    "time"
)

func main() {
    testmap := make(map[string]string)
    mutex := sync.rwmutex{}
    for i := 0; i < 64; i++ {
        mutex.lock()
        now := time.now().string()
        testmap[now] = now
        mutex.unlock()
    }
    go func() {
        for {
            mutex.lock()
            now := time.now().string()
            testmap[now] = now
            time.sleep(100 * time.millisecond)
            mutex.unlock()
        }
    }()
    for k, v := range testmap {
        mutex.rlock()
        _, _ = k, v
        mutex.runlock()
        time.sleep(100 * time.millisecond)
    }
}

输出：

$ go run -race racer.go
==================
warning: data race
read at 0x00c00008c060 by main goroutine:
  runtime.mapiternext()
      /home/peter/go/src/runtime/map.go:844 +0x0
  main.main()
      /home/peter/gopath/src/racer.go:26 +0x217

previous write at 0x00c00008c060 by goroutine 5:
  runtime.mapassign_faststr()
      /home/peter/go/src/runtime/map_faststr.go:202 +0x0
  main.main.func1()
      /home/peter/gopath/src/racer.go:21 +0x9b

goroutine 5 (running) created at:
  main.main()
      /home/peter/gopath/src/racer.go:17 +0x17b
==================
==================
warning: data race
read at 0x00c0000a6638 by main goroutine:
  main.main()
      /home/peter/gopath/src/racer.go:26 +0x1d0

previous write at 0x00c0000a6638 by goroutine 5:
  main.main.func1()
      /home/peter/gopath/src/racer.go:21 +0xb0

goroutine 5 (running) created at:
  main.main()
      /home/peter/gopath/src/racer.go:17 +0x17b
==================
fatal error: concurrent map iteration and map write

goroutine 1 [running]:
runtime.throw(0x4b1eb7, 0x26)
    /home/peter/go/src/runtime/panic.go:617 +0x72 fp=0xc000059e48 sp=0xc000059e18 pc=0x44d722
runtime.mapiternext(0xc000059f28)
    /home/peter/go/src/runtime/map.go:851 +0x55e fp=0xc000059ed0 sp=0xc000059e48 pc=0x434c2e
main.main()
    /home/peter/gopath/src/racer.go:26 +0x218 fp=0xc000059f98 sp=0xc000059ed0 pc=0x48a1f8
runtime.main()
    /home/peter/go/src/runtime/proc.go:200 +0x20c fp=0xc000059fe0 sp=0xc000059f98 pc=0x44f06c
runtime.goexit()
    /home/peter/go/src/runtime/asm_amd64.s:1337 +0x1 fp=0xc000059fe8 sp=0xc000059fe0 pc=0x475751

goroutine 4 [sleep]:
runtime.goparkunlock(...)
    /home/peter/go/src/runtime/proc.go:307
time.sleep(0x5f5e100)
    /home/peter/go/src/runtime/time.go:105 +0x159
main.main.func1(0xc00001c280, 0xc00008c060)
    /home/peter/gopath/src/racer.go:22 +0x3e
created by main.main
    /home/peter/gopath/src/racer.go:17 +0x17c
exit status 2
$

您没有锁定地图读取，

for k, v := range testmap {
    mutex.rlock()
    _, _ = k, v
    mutex.runlock()
    time.sleep(100 * time.millisecond)
}

for k, v := range testmap { ... } 读取地图。 k、v 是局部变量。

您需要锁定地图读取，

mutex.RLock()
for k, v := range testMap {
    _, _ = k, v
    time.Sleep(100 * time.Millisecond)
}
mutex.RUnlock()

Go: Data Race Detector

The Go Blog: Introducing the Go Race Detector

GopherCon 2016: Keith Randall - Inside the Map Implementation

今天关于《解决使用Go语言时阅读缓存DIY书籍时可能遇到的线程安全问题》的内容介绍就到此结束，如果有什么疑问或者建议，可以在golang学习网公众号下多多回复交流；文中若有不正之处，也希望回复留言以告知！