funcmain() { fmt.Println("main start") // main 函数的第一个语句是打印 main start 到控制台。 channel := make(chanstring) // 在 main 函数中使用 make 函数创建一个 string 类型的通道赋值给 ' channel ’ 变量 channel <- "GoLang" // 给通道 channel 传入一个数据 DEMO. // 此时主线程将阻塞直到有协程接收这个数据. Go 的调度器开始调度协程接收通道 channel 的数据 // 但是由于没有协程接受,没有协程是可被调度的。所有协程都进入休眠状态,即是主程序阻塞了。 fmt.Println("main stop") } /* 报错 main start fatal error: all goroutines are asleep - deadlock! //所有协程都进入休眠状态,死锁
goroutine 1 [chan send]: main.main() */
2.3 关闭通道
package main
import"fmt"
funcRushChan(c chanstring) { <- c fmt.Println("1") <- c fmt.Println("2") }
funcmain() { fmt.Println("main start") c := make(chanstring, 1) go RushChan(c) c <- "Demo1" close(c) /* 不能向一个关了的channel发信息 main start panic: send on closed channel */ c <- "Demo2" //close(c) /* close 放这里的话可以 main start 1 2 Main Stop */ fmt.Println("Main Stop") }
第一个操作 c <- "Demo2" 将阻塞协程直到有其他协程从此通道中读取数据,因此 greet 会被调度器调度执行。
funcmain() { fmt.Println("Main Start") c := make(chanstring) go greet(c) c <- "Demo" fmt.Println("Main Stop") } /* 结果 Main Start Hello Demo ! Main Stop */
我们修改 greet 协程函数,把参数 c 类型从双向通道改成单向接收通道。
现在我们只能从通道中读取数据,通道上的任何写入操作将会发生错误:
"invalid operation: roc <- "Temp" (send to receive-only type <-chan string)".
2.7 Select
select 和 switch 很像,它不需要输入参数,并且仅仅被使用在通道操作上。
Select 语句被用来执行多个通道操作的一个和其附带的 case 块代码。
2.7.1 原理
让我们来看下面的例子,讨论下其执行原理
package main
import ( "fmt" "time" )
var start time.Time
funcinit() { start = time.Now() }
funcservice1(c chanstring) { time.Sleep(3 * time.Second) c <- "Hello from service 1" }
funcservice2(c chanstring) { time.Sleep(5 * time.Second) c <- "Hello from service 2" }
select { case res := <-chan1: fmt.Println("Response form service 1", res, time.Since(start)) case res := <-chan2: fmt.Println("Response form service 2", res, time.Since(start)) }
fmt.Println("main stop ",time.Since(start)) }
/* 结果: main start 0s Response form service 1 Hello from service 1 3.0018445s main stop 3.0019815s */
从上面的程序来看,我们知道 select 语句和 switch 很像,不同点是用通道读写操作代替了布尔操作。通道将被阻塞,除非它有默认的 default 块 (之后将介绍)。一旦某个 case 条件执行,它将不阻塞。
所以一个 case 条件什么时候执行呢 ?
如果所有的 case 语句(通道操作)被阻塞,那么 select 语句将阻塞直到这些 case 条件的一个不阻塞(通道操作),case 块执行。
如果有多个 case 块(通道操作)都没有阻塞,那么运行时将随机选择一个不阻塞的 case 块立即执行。
为了演示上面的程序,我们开启两个协程并传入对应的通道变量。然后我们写一个带有两个 case 操作的 select 语句。 一个 case 操作从 chan1 读数据,另外一个从 chan2 读数据。这两个通道都是无缓冲的 , 读操作将被阻塞 。所以 select 语句将阻塞。因此 select 将等待,直到有 case 语句不阻塞。
select { case res := <-chan1: fmt.Println("Response form service 1", res, time.Since(start)) case res := <-chan2: fmt.Println("Response form service 2", res, time.Since(start)) }
fmt.Println("main stop ",time.Since(start)) }
结果一:
main start 0s
Response form service 1 Hello from service 1 539.3µs
main stop 539.3µs
结果二:
main start 0s
Response form service 2 Hello from service 2 0s
main stop 0s
结果一共有2!个不同的结果
为了证明当所有 case 块都是非阻塞的时候,golang 会随机选择一个代码块执行打印 response,我们使用缓冲通道来改造程序。
package main
import ( "fmt" "time" )
var start time.Time
funcinit() { start = time.Now() }
funcservice1(c chanstring) { c <- "Hello from service 1" }
funcservice2(c chanstring) { c <- "Hello from service 2" }
select { case res := <-chan1: fmt.Println("Response form service 1", res, time.Since(start)) case res := <-chan2: fmt.Println("Response form service 2", res, time.Since(start)) }
fmt.Println("main stop ",time.Since(start)) }
上述的程序的结果是有不同的
结果一:
main start 0s
Response form service 1 Value 1 496.2µs
main stop 496.2µs
结果二:
main start 0s
Response form service 2 Value 1 0s
main stop 0s
在上面的程序中,两个通道在其缓冲区中都有两个值。因为我们向容量为 2 的缓冲区通道分别发送了两个值,所以这些通道发送操作不会阻塞并且会执行下面的 select 块。 select 块中的所有 case 操作都不会阻塞,因为每个通道中都有两个值,而我们的 case 操作只需要取出其中一个值。因此,go 运行时会随机选择一个 case 操作并执行其中的代码。
2.7.2 default case 块
像 switch 一样, select 语句也有 default case 块。default case 块 是非阻塞的,不仅如此, default case 块可以使 select 语句永不阻塞,这意味着, 任何通道的 发送 和 接收 操作 (不管是缓冲或者非缓冲) 都不会阻塞当前线程。
如果有 case 块的通道操作是非阻塞,那么 select 会执行其 case 块。如果没有那么 select 将默认执行 default 块.
package main
import ( "fmt" "time" )
var start time.Time
func init() { start = time.Now() }
func service1(c chan string) { c <- "Hello from service 1" }
func service2(c chan string) { c <- "Hello from service 2" }
select { case res := <-chan1: fmt.Println("Response form service 1", res, time.Since(start)) case res := <-chan2: fmt.Println("Response form service 2", res, time.Since(start)) default: fmt.Println("No Response received",time.Since(start)) }
fmt.Println("main stop ",time.Since(start)) }
/* 结果: main start 0s No Response received 0s main stop 0s */
select { case res := <-chan1: fmt.Println("Response form service 1", res, time.Since(start)) case res := <-chan2: fmt.Println("Response form service 2", res, time.Since(start)) default: fmt.Println("No Response received",time.Since(start)) }
fmt.Println("main stop ",time.Since(start)) } /* 结果不唯一。 main start 0s service2 start service1 start Response form service 1 Hello from service 1 3.0006729s main stop 3.0006729s */
2.7.3 空 select
和 for{} 这样的空循环很像,空 select{} 语法也是有效的。但是有一点必须要说明。
我们知道 select 将被阻塞除非有 case 块没有阻塞。因为 select{} 没有 case 非阻塞语句,主线程将阻塞并可能会导致死锁。
package main
import"fmt"
funcservice() { fmt.Println("Hello from service") }
funcmain() { fmt.Println("main started") go service() select {} fmt.Println("main stop") } /* 结果 main started Hello from service fatal error: all goroutines are asleep - deadlock!
goroutine 1 [select (no cases)]: */
在上面的程序中我们知道 select 将阻塞 main 线程,调度器将会调度 service 这个协程。在 service 执行完毕后,调度器会再去调度其他可用的协程,但是此时已经没有可用的协程,主线程也正在阻塞,所以最后的结果就是发生死锁.
7. 多协程协同工作
写两个协程,一个用来计算数字的平方,另一个用来计算数字的立方。
package main
import"fmt"
funcsquare(c chanint) { fmt.Println("[square] reading") num := <-c c <- num * num }
funccube(c chanint) { fmt.Println("[cube] reading") num := <-c c <- num * num * num }
funcmain() { fmt.Println("[main] main started") squareChan := make(chanint) cubeChan := make(chanint) go square(squareChan) go cube(cubeChan)
testNum := 3
fmt.Println("[main] send testNum to squareChan") squareChan <- testNum fmt.Println("[main] resuming")
fmt.Println("[main] send testNum to cubeChane") cubeChan <- testNum fmt.Println("[main] resuming")
fmt.Println("[main] reading from channels") squareVal,cubeVal := <-squareChan, <-cubeChan sum := squareVal + cubeVal
fmt.Println("[main] sum of square and cube of",testNum," is",sum) fmt.Println("[main] main stop") }
/* 结果: [main] main started [main] send testNum to squareChan [cube] reading [square] reading [main] resuming [main] send testNum to cubeChane [main] resuming [main] reading from channels [main] sum of square and cube of 3 is 36 [main] main stop
*/
流程:
创建两个函数 square 和 cube 作为协程运行。
两个函数都有一个 int 类型通道参数 c,从 c 中读取数据到变量 num,最后把计算的数据再写入到通道 c 中。
在主线程中使用 make 函数创建两个 int 类型通道 squareChan and cubeChan
funcservice(wg *sync.WaitGroup, instance int) { time.Sleep(2 * time.Second) fmt.Println("Service called on instance",instance) wg.Done() //协程数-1 }
funcmain() { fmt.Println("main started") var wg sync.WaitGroup for i:=1;i<= 3; i++{ wg.Add(1) go service(&wg,i) } wg.Wait()//阻塞 fmt.Println("main stop") }
/* 结果:(结果是不唯一的,一共有3!次可能的结果) main started Service called on instance 2 Service called on instance 1 Service called on instance 3 main stop */
当前我们有 3 个 work 协程在工作,我们使用了 sleep 操作来模拟阻塞操作,所以调度器在某一个阻塞的时候会去调用其他的 work 协程,当某个 work 协程 sleep 完成后会把计算数字的平方的结果数据放入 results 缓冲无阻塞通道。
当 3 个协程依次交替把 task 通道的任务都完成后,for range 循环将完成,并且因为之前我们已经关闭了任务通道,所以协程也不会发生死锁。调度器将继续返回调度主线程。
有时候所有的工作协程可能都在阻塞,此时调度器将去调度主线程,直到 results 通道再次为空。
当所有 work 协程都完成任务退出后,主线程将继续拿到调度权并打印 results 通道剩下的数据,继续之后代码的执行。
9. Mutex
互斥是 Go 中一个简单的概念。在我解释它之前,先要明白什么是竞态条件。 goroutines 都有自己的独立的调用栈,因此他们之间不分享任何数据。但是有一种情况是数据存放在堆上,并且被多个 goroutines 使用。 多个 goroutines 试图去操作一个内存区域的数据会造成意想不到的后果.
package main
import ( "fmt" "sync" )
var i int
funcworker(wg *sync.WaitGroup) { i = i+1 wg.Done() }
funcmain() { fmt.Println("main started") var wg sync.WaitGroup for i:=0;i<1000;i++{ wg.Add(1) go worker(&wg) } wg.Wait() fmt.Println("main stop",i) } /* 结果是不同的!! main started main stop 985 */
i = i + 1 这个计算有 3 步
(1) 得到 i 的值
(2) 给 i 的值加 1
(3) 更新 i 的值
funcmain() { fmt.Println("main started") var wg sync.WaitGroup var m sync.Mutex for i:=0;i<1000;i++{ wg.Add(1) go worker(&wg,&m) } wg.Wait() fmt.Println("main stop",i) } /*结果 main started main stop 1000 */