Why does the code using locks in Go occasionally lead to panic?

Locks and panic in concurrent programming of Go language: A case analysis

This article discusses a common Go language concurrency programming problem: even if mutex is used, the code may still have panic: send on closed channel errors. Let's analyze the following code snippet:

 package main

import (
    "context"
    "fmt"
    "sync"
)

var lock sync.Mutex

func main() {
    c := make(chan int, 10)
    wg := sync.WaitGroup{}
    ctx, cancel := context.WithCancel(context.TODO())

    wg.Add(1)
    go func() {
        defer wg.Done()
        lock.Lock()
        cancel()
        close(c)
        lock.Unlock()
    }()

    // ... (Some of the senders code is omitted) ...
}

In this code, a goroutine is responsible for closing channel c and using lock to protect the critical section. However, even with lock protection, panic: send on closed channel may still appear.

The reason is the non-deterministic behavior of the Go language select statement. The Go language specification states that if there are multiple cases in the select statement that can be executed, the Go runtime will randomly select one execution. Therefore, even if close(c) has been executed, another goroutine(senders) select statement may still try to send data to c , resulting in panic.

Even though lock ensures that close(c) and sending operations do not occur simultaneously, the random selection feature of the select statement makes it possible to try to send data after close(c) , especially in high concurrency environments.

Therefore, the solution is not just a lock. A safer approach is:

• Check whether the channel is closed before sending data: Use if !isClosed := c == nil; isClosed to check the channel status.
• Use a buffered channel and control the buffer size: set the buffer size reasonably to reduce competition.
• Clearer concurrency control: Redesign the code logic to avoid simultaneously processing sending and receiving operations in select statements. For example, use a separate channel to coordinate the execution of the goroutine.

In short, in Go concurrent programming, relying solely on locks does not completely avoid all panic situations. It is necessary to combine the concurrency model characteristics of Go language and select appropriate concurrency control strategies to write robust and reliable concurrency programs.

The above is the detailed content of Why does the code using locks in Go occasionally lead to panic?. For more information, please follow other related articles on the PHP Chinese website!