go channel ＆＆ select

channel brief introduction

goroutine yes Go An important mechanism for implementing concurrency in ,channel yes goroutine An important bridge for communication between .channel It's a kind of go A secure message queue used by a process to receive or send messages ,channel It's like two go The catheter between the processes , To synchronize resources .

Reputation creation channel There are two common ways ,

// The way 1： Use make establish ( The data type it passes must be defined )
ch :make(chan int, 2)  // Create buffer channels 
ch :make(chan int)  // Create unbuffered channels 
ch :make(chan string, 0)  // Create unbuffered channels 



// The way 2： Use it directly var Statement 
var ch chan int

buffer channel And unbuffering channel

buffer channel： Have buffer , When the buffer is full , The sender will jam ; When the buffer is empty , The recipient will jam .

Simple use example , as follows

func main() {
        
	ch := make(chan int, 1) //  Create a type of int, The buffer size is 1 Of channel 
	ch <- 2 //  take 2 Send to ch 
	n, ok := <- ch // n Receive from ch The value of the emission  
	if ok {
            
		fmt.Println(n) //  Output ：2 
	}    
	close(ch) //  close channel
}

Use channel Points for attention ：

• To an already close fall Of channel Send a message , Will trigger panic;
• It is not allowed to report to the closed channel Send a message , But you can continue channel receive messages ;
• To one nil Of channel Send a message , It's going to keep clogging up ;
• When channel closed And channel The cache is empty when , Continue from channel Receiving a message will get a zero value of the corresponding type .

Non buffering channel： The buffer size is 0 Of channel, such channel The recipient of will block until the message is received , The sender will block until the receiver receives the message , This mechanism can be used for two goroutine State synchronization .

A simple example ：main In the function goroutine, Through the use of unbuffered queues , To be able to guarantee that goroutine Before the end of execution main The function does not exit prematurely , as follows ：

func worker(done chan bool){
    
    fmt.Println("start working...")
    done <- true
    fmt.Println("end working...")
}

func main() {
    
    done := make(chan bool, 1)
    go worker(done)
    <- done
}

select brief introduction

select Dedicated to channel send and receive operations , Looks like switch Very similar , But the methods of choice and judgment are completely different .

In the following example , adopt select Use , To ensure the worker The transaction in can be executed before exiting main function

func strWorker(ch chan string) {
    
    time.Sleep(1 * time.Second)
    fmt.Println("do something with strWorker...")
    ch <- "str"
}

func intWorker(ch chan int) {
    
    time.Sleep(2 * time.Second)
    fmt.Println("do something with intWorker...")
    ch <- 1
}

func main() {
    
    chStr := make(chan string)
    chInt := make(chan int)

    go strWorker(chStr)
    go intWorker(chInt)

    for i := 0; i < 2; i++ {
    
        select {
    
        case <-chStr:
            fmt.Println("get value from strWorker")

        case <-chInt:
            fmt.Println("get value from intWorker")

        }
    }
}