go - 为什么在主 goroutine 中评估 input.Text()

// Copyright © 2016 Alan A. A. Donovan & Brian W. Kernighan. // License: https://creativecommons.org/licenses/by-nc-sa/4.0/ // See page 224. // Reverb2 is a TCP server that simulates an echo. package main import ( "bufio" "fmt" "log" "net" "strings" "time" ) func echo(c net.Conn, shout string, delay time.Duration) { fmt.Fprintln(c, "\t", strings.ToUpper(shout)) time.Sleep(delay) fmt.Fprintln(c, "\t", shout) time.Sleep(delay) fmt.Fprintln(c, "\t", strings.ToLower(shout)) } //!+ func handleConn(c net.Conn) { input := bufio.NewScanner(c) for input.Scan() { go echo(c, input.Text(), 1*time.Second) } // NOTE: ignoring potential errors from input.Err() c.Close() } //!- func main() { l, err := net.Listen("tcp", "localhost:8000") if err != nil { log.Fatal(err) } for { conn, err := l.Accept() if err != nil { log.Print(err) // e.g., connection aborted continue } go handleConn(conn) } }

go关键字在 Go 中的工作原理，请参见Go_statements：

函数值和参数在调用 goroutine 中像往常一样被评估，但与常规调用不同，程序执行不会等待调用的函数完成。相反，该函数开始在一个新的 goroutine 中独立执行。当函数终止时，它的 goroutine 也会终止。如果函数有任何返回值，它们会在函数完成时被丢弃。

函数值和参数使用关键字就地评估（关键字相同，请参见关键字示例）。godeferdefer

要了解评估顺序，让我们试试这个：

go have()(fun("with Go."))

让我们运行它并阅读评估顺序的代码注释：

package main

import (
    "fmt"
    "sync"
)

func main() {
    go have()(fun("with Go."))

    fmt.Print("some ") // evaluation order: ~ 3
    wg.Wait()
}

func have() func(string) {
    fmt.Print("Go ") // evaluation order: 1
    return funWithGo
}

func fun(msg string) string {
    fmt.Print("have ") // evaluation order: 2
    return msg
}

func funWithGo(msg string) {
    fmt.Println("fun", msg) // evaluation order: 4
    wg.Done()
}

func init() {
    wg.Add(1)
}

var wg sync.WaitGroup

输出：

Go have some fun with Go.

解释 go have()(fun("with Go.")):
首次就地评估发生在这里：
go have()(...)第一have()部分运行，结果是fmt.Print("Go ")and return funWithGo，然后fun("with Go.")运行，结果是fmt.Print("have ")and return "with Go."；现在我们有了go funWithGo("with Go.")。

所以最后的goroutine调用是go funWithGo("with Go.")
This is a call to start a new goroutine 所以我们真的不知道它什么时候会运行。所以有机会运行下一行：fmt.Print("some ")，然后我们在这里等待wg.Wait()。现在 goroutine 运行它funWithGo("with Go.")，结果是fmt.Println("fun", "with Go.")then wg.Done(); 就这些。

让我们重写上面的代码，只是将命名函数替换为匿名函数，所以这段代码和上面一样：
例如看：

func have() func(string) {
    fmt.Print("Go ") // evaluation order: 1
    return funWithGo
}

并剪切这段代码，选中其中的have部分go have()并粘贴，然后选中其中的have部分func have()并在键盘上按Delete一下，然后你会得到这样的：
更漂亮，结果相同，只需将所有函数替换为匿名函数即可：

package main

import (
    "fmt"
    "sync"
)

func main() {
    var wg sync.WaitGroup
    wg.Add(1)

    go func() func(string) {
        fmt.Print("Go ") // evaluation order: 1
        return func(msg string) {
            fmt.Println("fun", msg) // evaluation order: 4
            wg.Done()
        }
    }()(func(msg string) string {
        fmt.Print("have ") // evaluation order: 2
        return msg
    }("with Go."))

    fmt.Print("some ") // evaluation order: ~ 3
    wg.Wait()
}

让我用一个简单的例子来解释它：
1. 考虑这个简单的代码：

i := 1
go fmt.Println(i) // 1

这很清楚：输出是1.

但是，如果 Go 设计者决定在~~函数运行时~~评估函数参数，那么没有人知道 ; 的值i。你可能会改变i你的代码（见下一个例子）

现在让我们做这个闭包：

i := 1
go func() {
    time.Sleep(1 * time.Second)
    fmt.Println(i) // ?
}()

输出真的是未知的，如果maingoroutine 早点退出，它甚至没有机会运行：唤醒并打印i，它i本身可能会改变到那个特定的时刻。

现在让我们像这样解决它：

i := 1
go func(i int) { 
    fmt.Printf("Step 3 i is: %d\n", i) // i = 1
}(i)

这个匿名函数参数是类型的int，它是一个值类型，并且值i是已知的，编译器生成的代码将值1（i）压入堆栈，所以这个函数，将使用值1，到时候（未来的某个时间）。

全部（围棋游乐场）：

package main

import (
    "fmt"
    "sync"
    "time"
)

func main() {
    i := 1
    go fmt.Println(i) // 1 (when = unknown)
    go fmt.Println(2) // 2 (when = unknown)

    go func() { // closure
        time.Sleep(1 * time.Second)
        fmt.Println(" This won't have a chance to run", i) // i = unknown  (when = unknown)
    }()

    i = 3
    wg := new(sync.WaitGroup)
    wg.Add(1)
    go func(i int) {
        defer wg.Done()
        fmt.Printf("Step 3 i is: %d\n", i) // i = 3 (when = unknown)
    }(i)

    i = 4

    go func(step int) { // closure
        fmt.Println(step, i) // i=? (when = unknown)
    }(5)
    i = 5
    fmt.Println(i) // i=5

    wg.Wait()
}

输出：

5
5 5
2
1
Step 3 i is: 3

Go Playground 输出：

5
5 5
1
2
Step 3 i is: 3

您可能会注意到，和的顺序1是2随机的，并且您的输出可能会有所不同（参见代码注释）。

go - 为什么在主 goroutine 中评估 input.Text()

问题描述

解决方案

推荐阅读