Golang's channel is closed

During the development process, we often need to use Golang's channel. When we use the channel to complete the task, we need to close the channel in time to avoid blocking, so as to achieve the effect of optimizing the program.

So, under what circumstances do you need to close the channel? How to close the channel correctly? In Golang, channel closing is indeed a relatively complex topic. Let's explore this topic below.

1. Why do you need to close the channel?

First of all, it needs to be clear that the channel does not have to be closed. In other words, Golang will automatically close the channel when the last pointer to the channel is destroyed. But not closing the channel will cause the following problems:

1. Memory leak. Unclosed channels will always occupy memory, waiting for data to be sent or received, causing memory leaks.
2. block. An unclosed channel will always wait for data to be sent or received. If the waiting time is too long, the program may be blocked.
3. Unable to release resources in time. In some scenarios, we need to use channels to coordinate the operations of multiple goroutines. If the channels are not closed in time, resources may not be released in time, thus affecting the running efficiency of the program.

2. How to close the channel correctly?

Now that we know why we need to close the channel, how do we close the channel correctly? In fact, Golang provides two ways to close the channel:

1. Use the close() function

The simplest and most common way to close the channel is to use the close provided by Golang ()function. The syntax format of this function is as follows:

close(channel)

This function needs to pass in a channel type parameter. When the passed channel type parameter is closed, it cannot be sent or received again, otherwise it will Cause panic.

2. Use a for range loop to close the channel

The second commonly used way to close a channel is to use a for range loop. This method is useful for receiving values ​​from the channel. Relatively common. For operations of sending data to a channel, this method is rarely used to close the channel. The code example of using the for range loop to close the channel is as follows:

for val := range channel {
    fmt.Println(val)
}

// channel被关闭后，上述代码会正常退出循环

In the for range loop, when the channel is closed, the loop will automatically end. It is worth noting that if we use statements such as break or continue in the for range loop to jump out of the loop, we cannot avoid the continued receiving operation of the channel.

3. How to avoid panic caused by channel closing?

When using the close() function to close a channel, one of the more important points to note is that we need to ensure that the channel is closed after all operations of sending all values ​​to the channel are completed, otherwise the channel will not be fully accepted. Performing a shutdown operation may cause panic. Let’s take a look at how to avoid this from happening.

1. Using cached channels

For some complex calculations or verification operations that need to be performed before sending data, we can use cached channels to avoid panic situations . The specific implementation is as follows:

ch := make(chan bool, 1)
go func() {
    // 进行复杂计算或者校验操作
    // ...
    ch <- true
}()

select {
case <- done:
    // 结束操作
case <- ch:
    // 处理收到的数据
}
close(ch)

In the above code, we use a channel with a buffer of 1. This channel only stores a Boolean value. When we complete the complex operation after creating the goroutine, we send a true value to the channel to indicate that the operation is completed. Then wait in the select statement to send values ​​to the channel or receive values ​​from other channels. Finally, we close the channel using the close() function.

2. Using the select statement

When using the select statement, we can use the default branch to handle the scenario before the channel is closed. The code example is as follows:

func handleCh(channel chan int) {
    for {
        select {
        case val, ok := <- channel:
            if !ok {
                fmt.Println("channel has closed")
                return
            }
            fmt.Println("recieve val:", val)
        default:
            fmt.Println("no value received")
        }
    }
}

func main() {
    ch := make(chan int)
    for i := 0; i < 5; i++ {
        go func(val int) {
            ch <- val
        }(i)
    }
    close(ch)
    handleCh(ch)
}

// 输出结果：
// recieve val: 0
// recieve val: 1
// recieve val: 2
// recieve val: 3
// recieve val: 4
// channel has closed

In the above code, we created a handleCh() function to process the value received from the channel. In this function, we use the select statement to process the data received from the channel, and handle the scenario when the channel is not closed in the default branch. When we close the channel in the main function, the handleCh() function will end normally. However, it should be noted that when using the default branch, it must be placed at the end, otherwise it will cause program errors.

4. Summary

Through the above introduction, we understand the reasons and methods of channel closing in Golang. Generally speaking, we need to close the channel manually to avoid problems such as memory leaks and blocking. When closing the channel, we need to use the close() function or the for range loop statement respectively to avoid panic. Currently in actual development, we can use cached channels or select statements to process the scene before the channel is closed, so as to optimize the program effect.

The above is the detailed content of Golang's channel is closed. For more information, please follow other related articles on the PHP Chinese website!