云原生系列Go语言篇-并发 Part 2

本文来自正在规划的Go言语&云原生自我提升系列，欢迎重视后续文章。

并发实践和形式

既然现已解说了Go为并发所供给的基础东西，咱们就来学习一些并发的最佳实践和形式吧。

坚持API无并发

并发是一种结束细节，好的API规划应当尽或许隐藏结束细节。这样在修改代码时无需修改其调用办法。

在实践中，这意味着永久不要在API的类型、函数及办法中暴露通道或互斥锁（咱们会在何时用互斥锁替换通道中讨论互斥锁）。假如暴露了通道，就将通道办理的责任交给API的运用者了。这标明运用者要关怀通道是否有缓冲、是否封闭或是nil。还有或许因拜访通道或互斥锁的顺序出问题而导致死锁。

注：这并不是说不能将通道作为函数参数或结构体参数。仅仅说不该导出。

这一规矩也有一些例外。假如API是一个带有并发协助函数的库（比方time.After，咱们会在怎样让代码超时一节中运用），通道就会是API的一部分。

协程、for循环及各种变量

大部分时分，用于发动协程的闭包没有任何参数。它是经过声明它的环境中捕获变量。有一个通用场景这种办法不适用，也便是尝试从获取for循环的索引或值时。以下代码包括一个隐藏的bug：

func main() {
    a := []int{2, 4, 6, 8, 10}
    ch := make(chan int, len(a))
    for _, v := range a {
        go func() {
            ch <- v * 2
        }()
    }
    for i := 0; i < len(a); i++ {
        fmt.Println(<-ch)
    }
}

咱们为a中的每个敞开一个协程。看起来咱们为每个协程传递了不同的值，但运转代码得到的成果却是：

20
20
20
20
20

每个协程对ch所写入的都是20的原因是，每个协程的闭包获取的是同一个变量。for循环中的索引和值变量在每次迭代中是复用的。最终一次对v所赋的值是10。运转协程时，这便是对协程可见的值。这一问题不仅仅对for循环，只需协程依赖的变量的值有或许发生变化，就有必要将值传递给协程。有两种结束办法。第一种是在循环内遮盖该值：

for _, v := range a {
    v := v
    go func() {
        ch <- v * 2
    }()
}

假如期望防止遮盖，让代码流更为明晰，也能够把值作为参数传递给协程：

for _, v := range a {
    go func(val int) {
        ch <- val * 2
    }(v)
}

小贴士：在协程运用的变量值会发生变化时，能够把值作为参数传递给协程：

一定要整理好协程

在发动协程函数时，必需求保证它最终会退出。与变量不同，Go运转时无法监测到协程是否不再运用。假如协程不退出，调度器仍然会定时给它时间，什么作业也不做，这会拖慢程序。这称为协程走漏（goroutine leak）。

协程是否会退出或许并不那么明显。比方，运用协程作为生成器：

func countTo(max int) <-chan int {
    ch := make(chan int)
    go func() {
        for i := 0; i < max; i++ {
            ch <- i
        }
        close(ch)
    }()
    return ch
}
func main() {
    for i := range countTo(10) {
        fmt.Println(i)
    }
}

注：这仅仅一个简略示例，不要运用协程生成数字列表。操作过分简略，违反了咱们“何时运用并发”的指导方针。

在这个常见用例中，咱们运用一切值的当地协程退出了。但假如循环过早退出，协程就会一向堵塞，等候从通道中读取值：

func main() {
    for i := range countTo(10) {
        if i > 5 {
            break
        }
        fmt.Println(i)
    }
}

done通道形式

done通道形式供给了一种发送信号通知协程中止进程的办法。它运用一个通道来发送退出信号。咱们来看向多个函数发送相同数据、但只需求最快函数的成果的示例：

func searchData(s string, searchers []func(string) []string) []string {
    done := make(chan struct{})
    result := make(chan []string)
    for _, searcher := range searchers {
        go func(searcher func(string) []string) {
            select {
            case result <- searcher(s):
            case <-done:
            }
        }(searcher)
    }
    r := <-result
    close(done)
    return r
}

在我的函数中，声明晰一个名称为done的通道，包括struct{}类型的数据。咱们运用了空结构体类型，由于其值并不重要，咱们不会向该通道写入，仅仅会封闭它。咱们为每个传入的搜索函数敞开一个协程。worker协程中的select句子会等候对result通道的写入（在searcher函数回来之时）或是对done通道的读取。回忆下读取敞开的通道会等候有数据可读而且读取已封闭通知总是会回来通道的零值。这意味着从done读取的分支会在封闭done前坚持等候状况。在searchData中，咱们读取第一个写入result的值，然后封闭done。这会向协程发送信息让其退出，防止协程走漏。

有时期望依据调用栈中前面函数中的内容来中止协程。在上下文一章中，咱们会学习怎样运用上下文来奉告一个或多个协程该封闭了。

运用cancel函数来终止协程

咱们也能够运用done通道来结束函数一章中所看到的一种形式：与通道一同回来吊销函数。咱们回到前面的countTo示例来了解是怎样运用的。吊销函数有必要在for循环之后调用：

func countTo(max int) (<-chan int, func()) {
    ch := make(chan int)
    done := make(chan struct{})
    cancel := func() {
        close(done)
    }
    go func() {
        for i := 0; i < max; i++ {
            select {
            case <-done:
                return
            case ch<-i:
            }
        }
        close(ch)
    }()
    return ch, cancel
}
func main() {
    ch, cancel := countTo(10)
    for i := range ch {
        if i > 5 {
            break
        }
        fmt.Println(i)
    }
    cancel()
}

countTo函数创立了两个通道，一个回来数据，另一个发出结束的信息。这儿没有直接回来结束通道，而是创立一个封闭结束通道的闭包并回来该闭包。经过闭包来吊销让咱们能够在需求时履行一些额定的整理作业。

何时运用缓冲和无缓冲通道

把握Go并发最杂乱的一项技能是决议何时运用缓冲通道。默许，通道是无缓冲的，这很简略了解：一个协程写入并等候另一个协程接纳，就像是接力赛中的接力棒一样。缓冲通道就更杂乱了。需求挑选巨细，由于缓冲通道中的缓冲是有极限的。恰当的运用缓冲通道意味着咱们有必要处理缓冲满了写入协程等候读取的堵塞状况。那怎样算是恰当地运用缓冲通道呢？

缓冲通道的场景很奇妙。能够一句话总结如下：

缓冲通道用于的场景是知道要发动多少个协程、期望限制发动的协程的数量或是限制排队处理使命的数量。

缓冲通道可很优点理的使命有从一组所发动的协程中收集数据或是期望限制并发的运用。它们有助于办理体系中排队的使命数量、防止服务来不及处理而崩溃。下面有一些示例可展示其运用场景。

第一个比方中，咱们处理通道上的前10条成果。这时咱们发动10个协程，每个协程将成果写入到缓冲通道上：

func processChannel(ch chan int) []int {
    const conc = 10
    results := make(chan int, conc)
    for i := 0; i < conc; i++ {
        go func() {
            v := <- ch
            results <- process(v)
        }()
    }
    var out []int
    for i := 0; i < conc; i++ {
        out = append(out, <-results)
    }
    return out
}

咱们切当地知道所发动的协程数量，而且期望每个协程在结束使命后退出。这标明咱们能够为每个发动协程创立一个带一个空间的缓冲通道，并让每个协程无堵塞地写入到这个协程。能够遍历这个缓冲通道，读取其间写入的值。读取完一切值后，回来成果，咱们知道不会产生协程走漏。

背压（backpressure）

另一项可经过缓冲通道结束的技能是背压机制。这有些反直觉，但在组件限制了期望履行的作业量后体系的功用会全体变好。咱们能够运用缓冲通道和select句子来限制体系中同步恳求的数量：

type PressureGauge struct {
    ch chan struct{}
}
func New(limit int) *PressureGauge {
    ch := make(chan struct{}, limit)
    for i := 0; i < limit; i++ {
        ch <- struct{}{}
    }
    return &PressureGauge{
        ch: ch,
    }
}
func (pg *PressureGauge) Process(f func()) error {
    select {
    case <-pg.ch:
        f()
        pg.ch <- struct{}{}
        return nil
    default:
        return errors.New("no more capacity")
    }
}

在这段代码中，咱们创立了一个带缓冲通道结构体，具有一些“令牌”和一个函数。每次协程期望运用函数时，它会调用Process。select尝试从通道读取令牌。假如能够读取则运转函数，并将令牌回来给缓冲通道。假如无法读取到令牌，则运转default分支，就会回来过错。下面有一个快速示例对内置的HTTP服务器运用这段代码（咱们会在规范库一章学习到怎样运用HTTP服务器）：

func doThingThatShouldBeLimited() string {
    time.Sleep(2 * time.Second)
    return "done"
}
func main() {
    pg := New(10)
    http.HandleFunc("/request", func(w http.ResponseWriter, r *http.Request) {
        err := pg.Process(func() {
            w.Write([]byte(doThingThatShouldBeLimited()))
        })
        if err != nil {
            w.WriteHeader(http.StatusTooManyRequests)
            w.Write([]byte("Too many requests"))
        }
    })
    http.ListenAndServe(":8080", nil)
}

封闭select中的分支

在需求从多个并发源中兼并数据时，select要害字可完美担任。但需求适当地处理封闭的通道。假如select中的一个分支在读取封闭的通道，总是会成功，回来的是零值。每次选取一个分支时，需求检测值是有用的并跳过分支。假如读取出现问题，程序会浪费许多时间读取垃圾值。

这时，咱们依赖这样的过错：读取一个nil通道。前面学到过，读取或写入nil通道会导致代码永久挂起。尽管在由bug引发时会很糟糕，但咱们能够运用nil通道来让select中的case无效。在监测到通道封闭时，将通道变量设置为nil。关联的分支就无法运转，由于从nil通道读取不会回来任何值：

// in和in2都是通道, done是结束channel.
for {
    select {
    case v, ok := <-in:
        if !ok {
            in = nil // 这一分支永久不再会成功!
            continue
        }
        // 处理从in中读取的v
    case v, ok := <-in2:
        if !ok {
            in2 = nil // 这一分支永久不再会成功!
            continue
        }
        // 处理从in2中读取的v
    case <-done:
        return
    }
}

怎样让代码超时

大部分交互程序需求在一定时间内回来响应。Go并发能够做的一个使命是办理恳求（或恳求的一部分）要运转多长时间。其它言语在promise和future之上引入了额定的特性来添加这一功用，但Go的超时句子展示了怎样经过已有功用构建杂乱的特性。咱们来一窥终究：

func timeLimit() (int, error) {
    var result int
    var err error
    done := make(chan struct{})
    go func() {
        result, err = doSomeWork()
        close(done)
    }()
    select {
    case <-done:
        return result, err
    case <-time.After(2 * time.Second):
        return 0, errors.New("work timed out")
    }
}

在需求对Go中的操作进行限时时，就会看到这一形式的变体。这儿的select有两个分支。第一个分支运用了前面学过的结束通道形式。咱们运用协程闭包来对result和err赋值，并封闭done通道。假如done通道先封闭了，对done的读取成功并回来该值。

第二个通道由time包中的After函数回来。在传递完指定的time.Duration之后会写入一个值。（咱们会在规范库一章中讲到time包）。在doSomeWork结束前读取到这个值时，timeLimit会回来超时过错。

注：假如在协程结束处理前退出timeLimit，协程会持续运转。咱们仅仅不再对其（最终）回来的成果进行处理。假如期望中止不再等候的协程的使命，可运用上下文吊销。在上下文一章中会进行讨论。

运用WaitGroup

有时一个协程需求等候多个协程先结束使命。假如等候的是单个协程，能够运用之前学习的结束通道形式。但假如等候的是多个协程，就需求运用WaitGroup，它位于规范库的sync包中。下面是一个简略示例，可在The Go Playground中运转：

func main() {
    var wg sync.WaitGroup
    wg.Add(3)
    go func() {
        defer wg.Done()
        doThing1()
    }()
    go func() {
        defer wg.Done()
        doThing2()
    }()
    go func() {
        defer wg.Done()
        doThing3()
    }()
    wg.Wait()
}

sync.WaitGroup声明时无需进行初始化，由于其零值也是有用的。sync.WaitGroup有三个办法：Add用于添加所等候的协程数；Done用于减少其计数器，在协程结束时调用；Wait等候协程直到计数器变为0。Add通常只调用一次，传递的是要发动的协程数。Done在协程内调用。要保证即便协程崩溃也会被调用，咱们运用了defer。

读者会注意到咱们没有显式传递sync.WaitGroup。有两个原因。其一是有必要保证一切运用sync.WaitGroup的当地都运用的是同一个实例。如传将sync.WaitGroup传递给协程函数而又没运用指针，那么函数得到的便是一个复制，Done就不会减少原始sync.WaitGroup的计算器。经过运用闭包来获取sync.WaitGroup，就能保证一切的协程都指向同一个实例。

其二是出于规划原因。还记得咱们应将并发保留在API之外吧。在前面的通道里咱们看到，通常的形式是运用包括业务逻辑的闭包发动协程。闭包办理并发的问题而函数供给算法。

咱们再来看一个更真实的示例。前面说到在多个协程写入同一个通道时，咱们需求保证所写入的通道只会封闭一次。sync.WaitGroup就很能担任这一要求。咱们来看并发处理通道中值、将成果收集到切片再回来切片的函数是怎样作业的：

func processAndGather(in <-chan int, processor func(int) int, num int) []int {
    out := make(chan int, num)
    var wg sync.WaitGroup
    wg.Add(num)
    for i := 0; i < num; i++ {
        go func() {
            defer wg.Done()
            for v := range in {
                out <- processor(v)
            }
        }()
    }
    go func() {
        wg.Wait()
        close(out)
    }()
    var result []int
    for v := range out {
        result = append(result, v)
    }
    return result
}

在这个比方中，咱们发动了监控协程等候一切处理的协程退出。在都退出时，监控协程会对输出通道调用close。在out封闭及缓冲为空时for-range通道循环会退出。最终，函数回来处理所得到值。

尽管WaitGroup很方便，在分配协程时不该将其作为首选。仅在一切作业协程退出后需求进行整理时（比方封闭写入的通道）才运用它。

GOLANG.ORG/X和ERRGROUP

Go作者维护了一些弥补规范库的东西。全体称为golang.org/x包，包括有一个ErrGroup类型，构建于WaitGroup之上用于创立一组在其间之一出现问题就中止处理的协程。阅读ErrGroup文档了解更多内容。

代码精确地只运转一次

在init函数：能免则免中咱们讲到，init应保留用于初始化有用的不可变包级状况。但有时咱们期望进行懒加载，或是有些代码要求在程序运转后只初始化一次。这通常是由于初始化相对较慢，乃至是并不是每次运转时都需求。sync包有一个方便的类型Once，结束了这一功用。咱们来快速看看怎样运用：

type SlowComplicatedParser interface {
    Parse(string) string
}
var parser SlowComplicatedParser
var once sync.Once
func Parse(dataToParse string) string {
    once.Do(func() {
        parser = initParser()
    })
    return parser.Parse(dataToParse)
}
func initParser() SlowComplicatedParser {
    // 在这儿做各种配置和加载
}

咱们声明晰两个包级变量，parser的类型为Compl⁠ica⁠tedParser，once的类型为sync.Once。相似sync.WaitGroup，咱们不需求配置sync.Once的实例（这称为让零值有价值）。仍是相似sync.WaitGroup，咱们有必要保证不生成sync.Once的复制，由于每个复制都运用其自身的状况来标明是否已运用。通常不该在函数内声明sync.Once实例，由于每次函数调用会创立新实例，并不会记录之前的调用。

在本例，咱们期望保证parser只初始化了一次，因咱们在传递给once的Do办法内设置了parser的值。假如Parse调用了屡次，once.Do不会重复履行闭包。

组兼并发东西

咱们回到本章第一节中的示例。有一个函数调用三个web服务。咱们向其间两个服务发送数据，然后接纳这两个调用的成果发送给第三个服务，回来成果 。整个过程要小于50毫秒，不然回来过错。

先从调用的函数开始：

func GatherAndProcess(ctx context.Context, data Input) (COut, error) {
    ctx, cancel := context.WithTimeout(ctx, 50*time.Millisecond)
    defer cancel()
    p := processor{
        outA: make(chan AOut, 1),
        outB: make(chan BOut, 1),
        inC:  make(chan CIn, 1),
        outC: make(chan COut, 1),
        errs: make(chan error, 2),
    }
    p.launch(ctx, data)
    inputC, err := p.waitForAB(ctx)
    if err != nil {
        return COut{}, err
    }
    p.inC <- inputC
    out, err := p.waitForC(ctx)
    return out, err
}

首要咱们设置了50毫秒超时的上下文。在没上下文时，运用其计时器而不是调用time.After。运用上下文计时器的一个优点是它让咱们能够考虑调用该函数的函数所设定的超时。咱们会在上下文一章讨论上下文，并在其间的计时器一节详细解说超时的运用。现在读者只需求知道超时后会撤销上下文。上下文的Done会回来上下文吊销时回来值的通道，撤销能够是超时或显式调用上下文的撤销办法。

在创立上下文之后，咱们运用defer来保证会调用上下文的cancel函数。在上下文一章中吊销一节中会讲到，有必要调用这一函数，不然会出现资源走漏。

然后会经过一系列用于与协程通讯的通道来填充processor实例。每个通道都有缓冲，因而履行写入的协程能够结束写入不等候读取就退出。（errs通道缓冲巨细为2，由于写入时或许会产生两个过错。）

processor结构如下：

type processor struct {
    outA chan AOut
    outB chan BOut
    outC chan COut
    inC  chan CIn
    errs chan error
}

接着，咱们对processor调用launch办法来敞开三个协程：一个用于调用getResultA，一个调用getResultB，还有一个调用getResultC：

func (p *processor) launch(ctx context.Context, data Input) {
    go func() {
        aOut, err := getResultA(ctx, data.A)
        if err != nil {
            p.errs <- err
            return
        }
        p.outA <- aOut
    }()
    go func() {
        bOut, err := getResultB(ctx, data.B)
        if err != nil {
            p.errs <- err
            return
        }
        p.outB <- bOut
    }()
    go func() {
        select {
        case <-ctx.Done():
            return
        case inputC := <-p.inC:
            cOut, err := getResultC(ctx, inputC)
            if err != nil {
                p.errs <- err
                return
            }
            p.outC <- cOut
        }
    }()
}

getResultA和getResultB的协程差不多。它们别离调用各自的办法。假如回来了过错，将过错写入p.errs通道。假如回来了有用值，将值写入通道中（getResultA的成果写入p.outA，getResultB的成果写入p.outB）。

由于只要在getResultA和getResultB成功而且在50毫秒内结束才调用getResultC，第三个协程稍显杂乱。它包括带两个分支的select。第一个在上下文吊销时触发。第二个在调用getResultC的数据存在时触发。假如数据存在，函数进行了调用，这个逻辑与前两个协程的逻辑相似。

在协程发动后，咱们调用processor的waitForAB办法：

func (p *processor) waitForAB(ctx context.Context) (CIn, error) {
    var inputC CIn
    count := 0
    for count < 2 {
        select {
        case a := <-p.outA:
            inputC.A = a
            count++
        case b := <-p.outB:
            inputC.B = b
            count++
        case err := <-p.errs:
            return CIn{}, err
        case <-ctx.Done():
            return CIn{}, ctx.Err()
        }
    }
    return inputC, nil
}

这运用for-select循环来对CIn实例一起也是的getResultC参数inputC赋值。共4个分支。前两个读取前两个协程所写入的通道并对inputC的字段赋值。假如这两个分支都履行了，咱们会退出for-select循环并回来inputC的值，和nil过错。

后两个分支处理过错条件。假如p.errs通道中写入了过错，就回来该过错。假如上下文被吊销了，咱们回来标明恳求被吊销的过错。

回到GatherAndProcess，咱们履行了一个规范的nil过错检测。假如正常，将inputC的值写入p.inC通道，然后调用processor的waitForC办法：

func (p *processor) waitForC(ctx context.Context) (COut, error) {
    select {
    case out := <-p.outC:
        return out, nil
    case err := <-p.errs:
        return COut{}, err
    case <-ctx.Done():
        return COut{}, ctx.Err()
    }
}

这个办法包括一个select。假如getResultC成功结束，咱们从p.outC通道读取输出并回来。假如getResultC回来过错，咱们从p.errs读取过错并回来。最终，假如上下文被吊销了，咱们回来一个相应的过错。在waitForC结束后，GatherAndProcess将成果回来给其调用者。

假如确认getResultC的作者会做正确的事，代码可进行简化。由于上下文传递给了getResultC，该函数能够考虑超时进行写入，在超时后回来过错。这样，咱们能够在GatherAndProcess中直接调用getResultC。这就能够去掉processor中的inC和outC、launch中的一个协程以及整个waitForC办法。总的原则是在程序正确的状况下运用尽量少的并发。

经过运用协程、通道和select句子架构代码，咱们分成了不同的步骤，允许各部分以任意顺序运转和结束，而且在各部分间明晰地交的数据。此外咱们还保证了程序的任意部分不会挂起，而且恰当地处理了函数自身及调用前史中其它函数的超时。假如不相信这是结束并发更好的办法，请尝试运用其它言语进行结束。或许会惊讶于其结束难度。

何时用互斥锁替换通道

如在其它编程言语中分配跨线程数据拜访，或许会运用互斥锁（*mutex-*mutual exclusion的缩写）。互斥锁的使命是限制一些代码的并发履行或是拜访同一块数据。所维护的部分称为要害段（critical section）。

Go作者们规划通道和select来办理并发有许多很好的原因。互斥锁的首要问题是它模糊了程序内的数据流。数据经过一系列通道从一个协程传入另一个协程时，数据流是明晰的。对值的拜访在一段时间内会本地化某个协程中。在运用互斥锁维护一个值时，无法标明哪个协程当时具有值的一切权，由于对值的拜访由一切并发进程同享。这就很难了解处理顺序。Go社区中有一个描绘这一哲学的名言：“经过通讯同享内存，而不是经过同享内存来通讯”。

话虽如此，有时运用互斥锁会更为明晰，所以Go规范库包括了适用这些场景的互斥锁结束。最常见的状况是协程读取或写入一个同享值，但不对值进行处理。咱们以多玩家游戏的内存计分板为例。首要看怎样运用通道结束。下面是一个可运用协程发动办理计分板的函数：

func scoreboardManager(in <-chan func(map[string]int), done <-chan struct{}) {
    scoreboard := map[string]int{}
    for {
        select {
        case <-done:
            return
        case f := <-in:
            f(scoreboard)
        }
    }
}

该函数声明晰一个字典，然后监听通道中读取或修改字典的函数，以及一个确认何时封闭的通道。咱们创立类型和将值写入字典的办法：

type ChannelScoreboardManager chan func(map[string]int)
func NewChannelScoreboardManager() (ChannelScoreboardManager, func()) {
    ch := make(ChannelScoreboardManager)
    done := make(chan struct{})
    go scoreboardManager(ch, done)
    return ch, func() {
        close(done)
    }
}
func (csm ChannelScoreboardManager) Update(name string, val int) {
    csm <- func(m map[string]int) {
        m[name] = val
    }
}

更新办法十分简洁，仅仅传递一个将值放入字典的函数。但怎样读取计分板呢？咱们需求回来一个值。这意味着运用结束形式等候传入ScoreboardManager的函数结束运转：

func (csm ChannelScoreboardManager) Read(name string) (int, bool) {
    var out int
    var ok bool
    done := make(chan struct{})
    csm <- func(m map[string]int) {
        out, ok = m[name]
        close(done)
    }
    <-done
    return out, ok
}

尽管代码运转正常，但这很粗笨而且一次只能有一个读取器。更好的办法是运用互斥锁。规范库中有两个互斥锁结束，都位于sync包中。第一个名为Mutex，它有两个办法Lock和Unlock。只需另一个协程处于要害段调用Lock会导致当时协程暂停。在清楚了要害段后，当时协程会获取到锁，要害段中的代码会履行。调用Mutex中的Unlock办法标志着要害段的终结。

第二种互斥锁的结束名为RWMutex，它让咱们获取读锁和写锁。要害段中一次只能获取一个writer，但读锁是同享的，要害段中一次可获取多个reader。写锁经过Lock和Unlock办法来办理，而读锁由RLock和RUnlock办法办理。

在获取互斥锁时，必需求保证你会开释锁。在调用Lock或RLock后运用defer句子来调用Unlock：

type MutexScoreboardManager struct {
    l          sync.RWMutex
    scoreboard map[string]int
}
func NewMutexScoreboardManager() *MutexScoreboardManager {
    return &MutexScoreboardManager{
        scoreboard: map[string]int{},
    }
}
func (msm *MutexScoreboardManager) Update(name string, val int) {
    msm.l.Lock()
    defer msm.l.Unlock()
    msm.scoreboard[name] = val
}
func (msm *MutexScoreboardManager) Read(name string) (int, bool) {
    msm.l.RLock()
    defer msm.l.RUnlock()
    val, ok := msm.scoreboard[name]
    return val, ok
}

咱们现已看到互斥锁的结束了，请在运用时仔细考虑你的挑选。Katherine Cox-Buday杰出的《Go言语并发之道》中有一个决策树，可协助咱们决议该运用通道仍是互斥锁：

• 假如在分配协程或追踪由一系列协程所转化的值，运用通道。
• 假如同享对结构体中字段的拜访，运用互斥体。
• 假如在运用通道时发现严峻功用问题（参见编写测试一章的基准测试），而且无法找到其它办法修正这一问题，将代码修改为运用互斥锁。

由于计分板是结构体中的一个字段，没有对计分板的传输，运用互斥锁在情理之中。这儿运用互斥锁很好，由于数据在内存中存储。假如数据存储在外部服务中，比方在HTTP服务器或数据库中，不要运用互斥锁来护卫对体系的拜访。

互斥锁要求咱们做更多的办理。比方，有必要正确地配对加锁和解锁，不然程序或许会死锁。咱们示例在同一个办法中获取并开释了锁。另一个问题是Go中互斥锁并不是可重入的（reentrant）。假如一个协程尝试重复获取同一个锁，会出现死锁，等候它自己开释锁。这与Java这类言语不同，它们的锁是可重入的。

不可重入锁让递归调用自己的函数获取锁变得费事。有必要在递归函数调用前开释锁。总归，在持有锁时注意函数的调用，由于不知道在这些调用中会获取哪些锁。假如函数调用了另一个尝试获取同一把锁的函数，协程就会死锁。

和sync.WaitGroup及sync.Once一样，不要复制互斥锁。假如将它们传入函数或以结构体中的一个字段进行拜访，有必要经过指针。假如复制了互斥锁，其锁无法同享。

警告：不要尝试用多个协程拜访同一个变量，除非先获得到了该变量的互斥锁。它或许会导致难以追踪的古怪过错。参见编写测试一章中的经过竞赛检测查找并发问题来学习怎样监测这些问题。

SYNC.MAP-这是不你以为的字典

在查看sync包时，会发现一个名为的Map的类型。它供给了Go内置的map的并发安全版本。因其结束中所做的权衡，sync.Map仅适用于特定场景：

• 在同享字典中键值对只刺进一次但读取屡次时
• 在协程同享字典，但不拜访互相的键和值时

此外，由于Go前期没有泛型，sync.Map运用interface{}作为其键和值的类型，编译器无法协助咱们确认所运用的正确的数据类型。

由于有这些限制，在极少数场景中咱们需求在多个协程间同享字典，运用由sync.RWMutex维护的内置map。

Atomic-你或许用不上

除了互斥锁，Go供给了其它办法可坚持跨线程的数据一致性。sync/atomic包供给了对内置到现代CPU中原子变量运算的拜访，用于添加、交流、加载、存储或比较交流（CAS）一个能装到单个寄存器中的值。

假如需求压榨出最终一点功用，而且是编写并发代码的专家，你会乐于见到Go包括对原子运算的支持。关于剩下的人，请运用协程和互斥锁办理并发需求。

在哪里深入学习并发

这儿咱们解说了一些简略并发形式，但还有许多其它常识。事实上，能够写一整本书来解说正确结束Go中各种并发形式，所幸Katherine Cox-Buday就写了这样一本书。前面在讨论该决议运用通道仍是互斥锁时现已说到了这本书，《Go言语并发之道》，它关于与Go和并发相关的常识都是很好的读物。能够阅读这本书学习更多常识。

小结

本章中，咱们解说了并发并学习了为什么Go的办法比其它的传统并发机制更简略。在解说过程中，咱们还说明晰什么时分该运用并发以及一些并发规矩和形式。下一章中，咱们会快速学习Go的规范库，它全面拥抱现代计算机的“内置电池”价值观。