当前位置：首页 > 文章列表 > Golang > Go问答 > 为什么在主 goroutine 中评估 input.Text()

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

来源：Golang技术栈 2023-05-04 07:04:00 0浏览收藏

欢迎各位小伙伴来到golang学习网，相聚于此都是缘哈哈哈！今天我给大家带来《为什么在主 goroutine 中评估 input.Text()》，这篇文章主要讲到golang等等知识，如果你对Golang相关的知识非常感兴趣或者正在自学，都可以关注我，我会持续更新相关文章！当然，有什么建议也欢迎在评论留言提出！一起学习！

问题内容

在Go Programming Language 的第 8 章中，对并发回显服务器的描述如下：

由 go 启动的函数的参数在执行 go 语句本身时进行评估；因此 input.Text() 在主 goroutine 中被评估。

我不明白这一点。为什么input.Text()在主 goroutine 上进行评估？它不应该在 go echo() goroutine 中吗？

// 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)
    }
}

代码在这里：https ://github.com/adonovan/gopl.io/blob/master/ch8/reverb2/reverb.go

正确答案

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

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

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

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

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()
}

输出：