防止竞争条件：在 HTTP 处理程序中保护只读共享结构

欢迎各位小伙伴来到golang学习网，相聚于此都是缘哈哈哈！今天我给大家带来《防止竞争条件：在 HTTP 处理程序中保护只读共享结构》，这篇文章主要讲到等等知识，如果你对Golang相关的知识非常感兴趣或者正在自学，都可以关注我，我会持续更新相关文章！当然，有什么建议也欢迎在评论留言提出！一起学习！

我需要更新 struct 中的值并返回（只读）而不是从 http 处理程序写入，以避免出现竞争条件，我正在使用 sync.mutex 这是一个基本示例：

http://play.golang.org/p/21iimsdkp6e

package main

import (
    "encoding/json"
    "log"
    "net/http"
    "sync"
    "time"
)

type counter struct {
    count uint
    flag  bool
    mu    sync.mutex
    quit  chan struct{}
    time  time.time
    wg    sync.waitgroup
}

func (c *counter) start() {
    c.count = 1
    c.time = time.now()
    c.flag = true
}

func (c *counter) listen() {
    srv := &http.server{
        addr:    ":8080",
        handler: http.defaultservemux,
    }
    http.handlefunc("/", c.handlestatus)
    c.wg.add(1)
    go func() {
        defer c.wg.done()
        log.println(srv.listenandserve())
    }()
    go func(quit chan struct{}) {
        <-quit
        if err := srv.close(); err != nil {
            log.printf("http error: %v", err)
        }
    }(c.quit)
}

func (c *counter) handlestatus(w http.responsewriter, r *http.request) {
    c.mu.lock()
    defer c.mu.unlock()
    status := struct {
        count uint   `json:"count"`
        flag  bool   `json:"flag"`
        time  string `json:"time"`
    }{
        count: c.count,
        time:  c.time.utc().format(time.rfc3339),
        flag:  c.flag,
    }
    w.header().set("content-type", "application/json")
    if err := json.newencoder(w).encode(status); err != nil {
        log.println(err)
    }

}

func main() {
    c := &counter{
        quit: make(chan struct{}),
    }
    c.start()
    c.listen()
    timeout := time.after(time.minute)
    for {
        select {
        case <-time.after(time.second):
            c.mu.lock()
            c.count += 1
            c.flag = !c.flag
            c.mu.unlock()
        case <-timeout:
            close(c.quit)
            c.wg.wait()
            return
        }
    }
}

我有更多处理程序，但在需要从 counter 结构 读取的地方，我需要在每个处理程序上添加：

c.mu.lock()
defer c.mu.unlock()

在修改变量的地方，执行如下操作：

c.mu.Lock()
c.count += 1
c.flag = !c.flag
c.mu.Unlock()

因此想知道如何更好地同步/安排代码以防止在每个处理程序 lock/unlock 上添加

解决方案

您有几个选择：

1. 使用互斥体，如您现有的示例中所示（尽管如果大多数访问都是读取，则 RWMutex 会更高效）。
2. 将其包装在辅助函数中，这样您的处理程序就可以调用该函数来获取值，而不必直接操作锁，并且该函数将处理锁定/读取/解锁逻辑。
3. 彻底改变逻辑，让每个例程都有自己的本地值副本，并使用通道通知例程权威值的变化（通过通信来共享，而不是通过共享来通信）。

理论要掌握，实操不能落！以上关于《防止竞争条件：在 HTTP 处理程序中保护只读共享结构》的详细介绍，大家都掌握了吧！如果想要继续提升自己的能力，那么就来关注golang学习网公众号吧！