The purpose of select plus default is to allow select to perform default behavior when no other branches are ready to avoid program blocking. 1. When receiving data from the channel non-blocking, if the channel is empty, it will directly enter the default branch; 2. In combination with time.After or ticker, try to send data regularly, and skip it if the channel is full; 3. Prevent deadlocks, avoid program stuck when it is uncertain whether the channel is closed; when using it, please note that the default branch will be executed immediately and cannot be abused, and default and case are mutually exclusive and will not be executed at the same time.

In Go language, select statement is used to wait for multiple communication operations to complete. It's much like switch , but each case is a communication (channel operation). After adding the default branch, you can let select perform the default behavior when no other branches are ready.

What is the function of select plus default ?

select in Go is usually used to listen to read and write operations of multiple channels. Once one of the channels is ready, the corresponding case will be executed. But if all channels are not ready, the program will block by default until a channel is ready.

At this time, adding a default branch can break this blocking behavior. When no channel can communicate, the logic in default is executed. This is very useful in some scenarios, such as non-blocking checking channel state, avoiding deadlocks, or implementing polling mechanisms.

Common scenarios of using select default

1. Receive data from the channel non-blocking

Sometimes you don’t want to wait forever, but hope “if you have data to read now, forget it if you don’t have it.” At this time, you can use select default :

 select {
case msg := <-ch:
    fmt.Println("Message received:", msg)
default:
    fmt.Println("No message currently")
}

In this way, even if the channel is empty, the program will not be stuck, but will directly enter the default branch.

2. Timed polling or attempting to send data

You can combine time.After or ticker to try to do something regularly without blocking the main thread:

 select {
case ch <- "Try to send":
    fmt.Println("Sent successfully")
default:
    fmt.Println("channel is full, can&#39;t be sent for the time being")
}

In this example, if the channel is full, it will not block, but will skip directly.

3. Prevent select deadlock

In some concurrency logic, if you are not sure if the channel will be closed or if there is a goroutine running, you can use default to avoid deadlocks:

 done := make(chan bool)

go func() {
    // Close done after doing something
    time.Sleep(time.Second)
    close(done)
}()

select {
case <-done:
    fmt.Println("Task Complete")
default:
    fmt.Println("Not finished yet")
}

If there is no default here and the done channel has not been closed, the program will be stuck.

Several details to pay attention to when using

• default branch will be executed immediately when no channel is ready.
• Don't abuse default or it may mask the real blocking problem.
• If you want to choose one of multiple channels first, you can nest it multiple times or use it with for loop.
• default and case are mutually exclusive and will not be executed at the same time.

Give an example to illustrate the execution order:

 ch1 := make(chan string)
ch2 := make(chan string)

go func() {
    time.Sleep(100 * time.Millisecond)
    ch1 <- "From ch1"
}()

select {
case msg := <-ch1:
    fmt.Println(msg)
case msg := <-ch2:
    fmt.Println(msg)
default:
    fmt.Println("None is ready")
}

This code is likely to output "non-prepared" first, because neither channel is ready yet. But after a few milliseconds, ch1 will receive a value, but select has been executed, so it will not fall back and try again.

Let's summarize

select default is a flexible way to control channel behavior, especially suitable for scenarios where you don't want to get your program stuck. Although the structure is simple, it is important to understand its execution timing and scope of application.

Basically, that's all. If you master these points well, it will not be easy to make mistakes when you use them.

The above is the detailed content of Go select with default case. For more information, please follow other related articles on the PHP Chinese website!