What will happen first: cancellation signal processing or write completion if they occur simultaneously in a channel?

In Go, when attempting to send a cancellation signal (for example, by closing a channel or sending a value) and simultaneously closing a channel, the order of processing is not guaranteed and depends on the goroutine scheduler and channel states. Channels in Go synchronize operations, but if two operations occur simultaneously, one will be executed first, though this is not specified by the language.

That is, if a goroutine tries to send to a channel, and another goroutine simultaneously closes that channel or sends a cancellation signal, which operation is processed first is undefined. It is important to design logic so as not to rely on the order of such concurrent events.

Example:

cancel := make(chan struct{})
data := make(chan int)

// Goroutine listening for cancel
go func() {
    select {
    case <-cancel:
        fmt.Println("Cancellation received")
    case v := <-data:
        fmt.Println("Value received", v)
    }
}()

// Simultaneous send
close(cancel) // cancellation signal
// or
// data <- 42 // send to channel

In this example, which branch executes first depends on the scheduler.