大话状态协程

引言

与用互斥锁进行明确的锁定来让共享的 state 跨多个 Go 协程同步访问， 在golang中，更多的是基于通道的方法和Go 协程间通过通讯来共享内存。如果你对此已有所了解，本文对你毫无意义。

数据竟争

数据竞争，本质是多个请求对应同一共享数据的争抢，要么给数据上把锁，要么让请求排队，一个个上。

用锁

好比上公共洗手间，假定只有一个坑位，多个人同时来了，都有需求。进去的人关门上锁，外面的人等着。里面人用完了，出来解锁开门，下一个人接着使用。这种情况下，锁只有一把，不一定先来的人就能上厕所。问题的关键在于谁获取了锁。用锁，是对共享资源的保护

通信

使用内置的 Go 协程和通道的的同步特性，解决数据竞争。简单来说，就是让经过通道通信后，用间接方式对共享资源进行读写。

go通道的做法，与现实生活有相通之处。假如洗手间没有锁，大家都有权使用，都要用，怎么搞？常识上大家都守规矩，先到先得（有序）可以解决。其实还有另外一种变通，像go是这样操作，不停地通知资源的使用方，确保同一时刻只允许一个请求进来。类比面试，总有一个人站在门外通知面试者，“下一个”，然后面试者进来。仔细分析 这里其实存在两个问题，喊下一个这个动作是重复(意味着需要循环），另外不同的面试者，同一面试官，每次面一个，表明面试官需要不停切换面试者，用程序语言来讲，共享资源（面试官）与请求（面试者）之间执行流发生了改变 。站在公司的角度，面试者需要准备好，他是被动选择。假如洗手间会说话，用go通道来说，不是人去上洗手间，而是洗手间去通知那些等待上洗手间的人。有点控制反转的味道。这种需要来回切换的场景，恰好适合chan通道+goroutine，通道具有天然的队列结构，它的chan阻塞-->切换goroutine执行。

状态协程

go状态协程，这种通过通讯来共享内存，确保每块数据在使用时为单独的 Go 协程所有。通过通信来达到共享内存，讲白点，共享资源作为私有状态，其依据外部通信在goroutine内部进行读写，而对共享资源的使用依赖于chan（线程安全）通道，这就要求使用资源的对象，必须具备通信能力，对共享资源的操作，其实就是对该对象方法的操作，在方法体内可通过通道间接使用共享资源。

package main

import (
    "fmt"
    "math/rand"
    "sync/atomic"
    "time"
)

// 在这个例子中，state 将被一个单独的 Go 协程拥有。这就能够保证数据在并行读取时不会混乱。
//为了对 state 进行读取或者写入，其他的 Go 协程将发送一条数据到拥有的 Go协程中，然后接收对应的回复。
// 结构体 `readOp` 和 `writeOp`封装这些请求，并且是拥有 Go 协程响应的一个方式

type readOp struct {
    key  int
    resp chan int
}
type writeOp struct {
    key  int
    val  int
    resp chan bool
}

func main() {

    //  用来计算执行操作的次数
    var ops int64

    // `reads` 和 `writes` 通道分别将被其他 Go 协程用来发布读和写请求。
    reads := make(chan *readOp)
    writes := make(chan *writeOp)

    // 拥有私有的 `state`  Go状态 协程，反复响应到达的请求。
    // 先响应到达的请求，然后返回一个值到响应通道 `resp` 来表示操作成功（或者是 `reads` 中请求的值）
    go func() {
        var state = make(map[int]int)
        for {
            select {
            case read := <-reads:
                read.resp <- state[read.key]
            case write := <-writes:
                state[write.key] = write.val
                write.resp <- true
            }
        }
    }()

    // 启动 100 个 Go 协程通过 `reads` 通道发起对 state 所有者Go 协程的读取请求。
    // 每个读取请求需要构造一个 `readOp`，发送它到 `reads` 通道中，并通过给定的 `resp` 通道接收 结果
    for r := 0; r < 100; r++ {
        go func() {
            for {
                read := &readOp{
                    key:  rand.Intn(5),
                    resp: make(chan int)}
                reads <- read
                <-read.resp
                atomic.AddInt64(&ops, 1)
            }
        }()
    }

    // 用相同的方法启动 10 个写操作
    for w := 0; w < 10; w++ {
        go func() {
            for {
                write := &writeOp{
                    key:  rand.Intn(5),
                    val:  rand.Intn(100),
                    resp: make(chan bool)}
                writes <- write
                <-write.resp
                atomic.AddInt64(&ops, 1)
            }
        }()
    }

    // 让 Go 协程们跑 1s。
    time.Sleep(time.Second)

    // 最后，获取并报告 `ops` 值。
    opsFinal := atomic.LoadInt64(&ops)
    fmt.Println("ops:", opsFinal)
}

小结

基于 Go 协程的比基于互斥锁的稍复杂。这在某些例子中会有用，例如，在你有其他通道包含其中或者当你管理多个这样的互斥锁容易出错的时候。使用最自然的方法，特别是关于程序正确性的时候。

本作品采用《CC 协议》，转载必须注明作者和本文链接