Golang频道处理send！= receive

Consider the toy example below. The code works perfectly but when you interchange the 2 lines marked as replace, there will be a deadlock. Is there a better way to deal with such a situation when you have different number of sends and receives?

package main

import "fmt"
import "strconv"

func main() {
    a := make(chan string)
    b := make(chan string)

    go func() {
        for i := 0; i < 2; i++ {
            go func(i int) {
                fmt.Println(<-a)
                b <- strconv.Itoa(i) + "b" // replace
                a <- strconv.Itoa(i) + "a" // replace
            }(i)
        }
    }()

    a <- "0"
    for i := 0; i < 2; i++ {
        fmt.Println(<-b)
    }
}

EDIT: using a select statement, there's a chance that a gets picked up by the select and there's still no way to prevent a deadlock because the goroutines can't execute

package main

import "fmt"
import "strconv"

func main() {
    a := make(chan string)
    b := make(chan string)
    c := make(chan bool)
    cancel := make(chan bool)

    go func() {
        for i := 0; i < 2; i++ {
            go func(i int) {
                fmt.Println(<-a)
                b <- strconv.Itoa(i) + "b" // replace
                a <- strconv.Itoa(i) + "a" // replace
                c <- true
            }(i)
        }
    }()

    go func() {
        <-c
        <-c
        cancel <- true
    }()

    a <- "0"

loop:
    for {
        select {
        case ain := <-a:
            fmt.Println("select", ain)
        case bin := <-b:
            fmt.Println("select", bin)
        case <-cancel:
            break loop
        }
    }
}

Use select:

package main

import "fmt"
import "strconv"

func main() {
    a := make(chan string)
    b := make(chan string)

    go func() {
        for i := 0; i < 2; i++ {
            go func(i int) {
                fmt.Println(<-a)
                b <- strconv.Itoa(i) + "b" // replace
                a <- strconv.Itoa(i) + "a" // replace
            }(i)
        }
    }()

    // regardless of which comes in first, this will handle it 
    select {
    case ain <- a:
        fmt.Println("sent a", ain)
    case bin <- b:
        fmt.Println("sent b", bin)
    case <- cancel:
        break
    }
}

That example will sit and block for an item sent on either a or b channels.

Optionally I usually set a cancel token or a timeout.

Your original code deadlocks on the switch because you sent on B, where you were only listening on A. Golang requires you to be listening on the channel BEFORE you ever send to it. This is the pattern for multiple channels, not knowing which you are going to get first.