通过对通道进行多次写入来理解 golang 阻塞通道行为

在Golang实战开发的过程中，我们经常会遇到一些这样那样的问题，然后要卡好半天，等问题解决了才发现原来一些细节知识点还是没有掌握好。今天golang学习网就整理分享《通过对通道进行多次写入来理解 golang 阻塞通道行为》，聊聊，希望可以帮助到正在努力赚钱的你。

我是 golang 新手，正在尝试了解该语言中的并发性。我有一个代码，可以将一些值推送到通道，然后读取它们。

package main

import (
    "log"
    "time"
)

func Greet2(c chan string) {
    // logging to Stdout is not an atomic operation
    // so artificially, sleep for some time
    time.Sleep(2 * time.Second)
    
    // 5. until below line reads and unblock the channel
    log.Printf("5. Read Greet2:: %s\n\n", <-c)
}

func Greet(c chan string) {
    // 4. Push a new value to the channel, this will block
    // Process will look for other go routines to execute
    log.Printf("4. Add 'Greet::John' to the channel, block until it is read. Remember, 'Greet' goroutine will block and only other goroutines can run even though this go routine can pull the value out from the channel.\n\n")
    c <- "Greet::John!"
    
    // 8. This statement will never execute
    log.Printf("8. Read Greet:: %s !\n\n", <-c)
}

func main() {

    c := make(chan string)

    log.Println("1. Main start")
    
    // 2. Both go routine will be declared and both will
    // for a value to be inserted in the channel
    log.Println("2. Declare go routines.\n\n")
    go Greet(c)
    go Greet2(c)
    
    // 3. write will block
    log.Println("3. Add 'main::Hello' to the channel, block until it is read. Remember, 'main' goroutine will block and only other goroutines can run even though this go routine can pull the value out from the channel.\n\n")
    c <- "main::Hello"
    
    // Sleep to give time goroutines to execute
    time.Sleep(time.Second)
    
    // 6. read the channel value.
    log.Printf("6. Read main:: %s \n\n", <-c)
    
    // 7. Insert a new value to the channel
    log.Println("7. Add 'main::Bye' to the channel, block until it is read.\n")
    c <- "main::Bye"
    
    // Sleep to give time goroutines to execute
    time.Sleep(time.Second)
    log.Println("9. Main stop")

}

上述程序的输出是

2023/09/02 21:58:07 1. Main start
2023/09/02 21:58:07 2. Declare go routines.


2023/09/02 21:58:07 3. Add 'main::Hello' to the channel, block until it is read. Remember, 'main' goroutine will block and only other goroutines can run even though this go routine can pull the value out from the channel.


2023/09/02 21:58:07 4. Add 'Greet::John' to the channel, block until it is read. Remember, 'Greet' goroutine will block and only other goroutines can run even though this go routine can pull the value out from the channel.

2023/09/02 21:58:10 5. Read Greet2:: main::Hello

2023/09/02 21:58:11 6. Read main:: Greet::John!

2023/09/02 21:58:11 7. Add 'main::Bye' to the channel, block until it is read.

2023/09/02 21:58:11 8. Read Greet:: main::Bye !

2023/09/02 21:58:12 9. Main stop

我无法理解为什么 4.（另一个写入通道）在 5.（第一次从通道读取）之前执行，因为 3. 将阻塞，并且在读取值之前通道不可用来自它（在步骤 5. 中）。我是否误解了阻塞行为，在步骤 3. 中，只有 main goroutine 块和 Greet （在步骤 4. 中）可以向通道写入附加值？一个解释确实可以解决我的困惑:)

干杯， DD。

感谢您的回复，我已经创建了一个更简单的程序来演示。并发

package main

import (
        "fmt"
)

func do2(c chan int) {
        fmt.Println(<-c)
}

func do(c chan int) {
        // 4. this statement is trying to write another value "2" to the channel
        // Channel already contains "1" as the value which has not been read yet.
        // this statement will wait for "1" to get read and block the execution.
        // Scheduler will look for other goroutines that can execute.
        // However, this("do") is blocked as well as "main" is blocked too and
        // there are no other goroutines to execute.
        // Hence, will result in a "Deadlock" fatal error.
        c <- 2
        fmt.Println(<-c)
}

func main() {

        // 1. Declare a channel
        c := make(chan int)
        // 2. Declare "do" goroutine
        go do(c)
        // 3. write "1" to the channel
        // This will block and wait for program's other goroutines to read the value.
        // however, there is only "do" goroutine is defined can run at this point.
        // Scheduler, will try to run "do" goroutine.
        c <- 1
        go do2(c)

}

死锁可以通过交换c <- 1和go do2(c)语句来修复。

正确答案

在 Go 中，当您在通道上发送值时（步骤 3 中的 c <- "main::Hello"），发送 Goroutine 将阻塞，直到有另一个 Goroutine 准备好从通道接收值。然而，这并不意味着没有其他 goroutine 可以继续执行。在您的代码中， Greet 和 Greet2 协程都在等待来自通道的值，因此当您在步骤 3 中发送值时，其中一个（不保证是哪一个）将解除阻塞并继续执行。

让我一步步分解事件的顺序：

1. 主程序启动，您创建一个频道 c。
2. 您声明了两个 goroutine，Greet 和 Greet2，并且两者都在等待来自通道的值。
3. 您在通道上发送一个值“main::Hello”，这会阻塞主 goroutine，直到其他 goroutine 从通道读取数据。但是，两个 Goroutine 之一（Greet 或 Greet2）不会被阻止接收该值。
4. Greet 解除阻塞并继续执行。它记录消息“4. 将‘Greet::John’添加到频道...”并发送“Greet::John!”在频道上。这会再次阻塞 Greet，因为此时没有其他 goroutine 可以从通道中读取。
5. Greet2 解除阻塞并继续执行。它记录消息“5. Read Greet2:: main::Hello”并从通道读取值“main::Hello”。
6. Main 解锁，记录“6. Read main:: Greet::John!”并写着“问候::约翰！”来自频道。
7. Main 在通道上发送另一个值“main::Bye”。此时，Greet 在向通道写入时仍被阻止，而 Greet2 因未从通道读取而被阻止。
8. 由于 Greet 仍然在写入时被阻止，因此它永远不会记录“8. Read Greet:: main::Bye !”
9. 主要站点。

因此，理解此处行为的关键是，当您在通道上发送值时，它会解锁任何正在等待从通道读取数据的 goroutine。等待的 goroutine 解除阻塞的顺序是不确定的，取决于调度程序。在您的情况下，Greet2 碰巧首先被解锁，但也可能是 Greet。

总之，您观察到的行为与 Go 通道的工作方式完全一致，并且需要注意的是，竞争 Goroutines 之间的执行顺序无法保证。

以上就是本文的全部内容了，是否有顺利帮助你解决问题？若是能给你带来学习上的帮助，请大家多多支持golang学习网！更多关于Golang的相关知识，也可关注golang学习网公众号。