1.并发和并行
并行(parallel):指在同一时刻,有多条指令在多个处理器上同时执行。
并发(concurrency):指在同一时刻只能有一条指令执行,但是多个进程指令被快速的轮换执行,使得宏观上具有多个进程同时执行的效果,但在微观上并不是同时执行的,只是把时间分成若干段,使多个进程快速交替执行。
Go语言为并发编程而内置的上层API基于CSP(communicating sequential processes,顺序通信模型)模型。这就意味着显示锁都是可以避免的,因为Go语言通过安全的通道发送和接受数据以实现同步,这大大地简化了并发程序的编写。一般情况下,一个普通的计算机跑十几二十个线程就有点负载过大了,但是同样这台机器却可以轻松地让成百上千甚至上万个goroutine进行资源竞争。
2.goroutine
goroutine是Go并发设计的核心。Goroutine说到底其实就是协程,但是他比线程更小,十几个goroutine可能体现在底层就是五六个线程,Go语言内部帮你实现了这些goroutine之间的内存共享。执行goroutine只需要极少的栈内存(大概是4~5KB),当然会根据相应的数据伸缩。也正因为如此,可同时运行成千上万个并发任务。Goroutine比thread更易用、更高效、更轻便。
【1】创建一个goroutine
只需要在调用程序前面添加go关键字就可以创建一个协程。
package main import "fmt" import "time" func newTask() { for { fmt.Println("this is a newTask") time.Sleep(time.Second) //延时一秒 } } func main() { go newTask() //新建一个协程 for { fmt.Println("this is a main goroutine") time.Sleep(time.Second) //延时一秒 } }
输出:
可以看到两个for循环在同时运行
【2】goroutine退出方式
主协程退出了,其他协程也要跟着退出。
package main import ( "fmt" "time" ) //主协程退出了,子协程也要跟着退出 func main() { go func() { i := 0 for { i++ fmt.Println("子协程 i = ", i) time.Sleep(time.Second) if i == 2 { break } } }() i := 0 for { i++ fmt.Println("main i = ", i) time.Sleep(time.Second) if i == 2 { //当主协程中i=2时,主协程退出 break } } }
输出:
可以看到主协程退出后子协程也退出了。
【3】runtime包
- Runtime.Gosched()用于让出CPU时间片,让出当前goroutine的执行权限,调度器安排其他等待的任务执行,并在下次某个时候从该位置恢复执行。就像接力赛,A跑了一会碰到代码runtime.Gosched()就把接力棒交给了B了,A就歇着了,B继续跑。
package main import ( "fmt" "runtime" ) func main() { go func() { for i := 0; i < 2; i++ { fmt.Println("go") } }() for i := 0; i < 2; i++ { //让出时间片,先让别的协程执行,执行完后,再执行次协程 runtime.Gosched() fmt.Println("hello") } }
输出:
- 调用runtime.Goexit()立即终止当前goroutine,调度器确保所有已注册defer延迟调用被执行。
package main import ( "fmt" "runtime" ) func test() { defer fmt.Println("cccccccccccccccccc") // return //终止次函数 runtime.Goexit() //终止所在的协程 fmt.Println("bbbbbbbbbbbbbbbb") } func main() { go func() { fmt.Println("aaaaaaaaaaa") //调用别的函数 test() fmt.Println("dddddddddddd") }() //写一个死循环,让主协程不结束 for { } }
输出:
如果使用return输出为:
- 调用runtime.GOMAXPROCS()用来设置用来并行计算的CPU核数最大值,并返回之前的值。
package main import ( "fmt" "runtime" ) func main() { n := runtime.GOMAXPROCS(1) //指定核数 fmt.Println("n = ", n) for { go fmt.Print(1) fmt.Print(0) } }
输出太多就不展示了,需要解释的是:
第一次执行(runtime.GOMAXPROCS(1))时,最多同时只能有一个goroutine被执行。所以会打印很多一。过了一段时间后,GO语言调度器将其置为休眠,并唤醒另一个goroutine,这时候开始打印很多个0了,在打印的时候,goroutine是被调度到操作系统线程上的。
第二次执行(runtime.GOMAXPROCS(2))时,我们使用了两个CPU,所以两个goroutine可以一起被执行,以同样的频率交替打印0和1。
3.channel
Goroutine运行在相同的地址空间,因此访问内存必须做好同步。Goroutine奉行通过通信来共享内存,而不是共享内存来通信。引用类型channel是CSP模式的具体实现,用于多个goroutine通讯。其内布实现了同步,确保并发安全。
和map类似,channel也一个对应make创建的底层数据结构的引用。
当我们复制一个channel或用于函数参数传递时,我们只是拷贝了一个channel引用,因此调用者和被调用者将引用同一个channel对象。和其他的引用类型一样,channel的零值也是nil。
【1】通过channel解决资源占用,实现同步
下面的代码会产生资源抢占
package main import ( "fmt" "time" ) //打印机 func Printer(str string) { for _, data := range str { fmt.Printf("%c", data) time.Sleep(time.Second) } fmt.Println() } //person1执行完成之后,person2执行 func person1() { Printer("hello") } func person2() { Printer("world") } func main() { //创建两个协程,代表两个人,两个人同时使用打印机 go person1() go person2() //特地不让主协程结束,死循环 for { } }
输出:
通过管道通信解决资源抢占问题
package main import ( "fmt" "time" ) //全局变量,创建一个channel var ch = make(chan int) //打印机 func Printer(str string) { for _, data := range str { fmt.Printf("%c", data) time.Sleep(time.Second) } fmt.Println() } //person1执行完成之后,person2执行 func person1() { Printer("hello") /* 给管道写数据,只有当Printer("hello")执行完成之后,这句才会执行,person2中接收到管道中有 数据,就不会阻塞,从而执行Printer("world"),从而解决资源抢占问题。 */ ch <- 666 } func person2() { <-ch //从管道取数据,接收,如果通道没有数据他就会阻塞 Printer("world") } func main() { //创建两个协程,代表两个人,两个人同时使用打印机 go person1() go person2() //特地不让主协程结束,死循环 for { } }
输出:
【2】通过channel实现同步和数据交互
package main import ( "fmt" "time" ) func main() { //创建channel ch := make(chan string) defer fmt.Println("主协程也结束") go func() { defer fmt.Println("子协程调用完毕") for i := 0; i < 2; i++ { fmt.Println("i = ", i) time.Sleep(time.Second) } ch <- "我是子协程,我工作完毕" }() str := <-ch //没有数据前,阻塞 fmt.Println("str = ", str) }
输出:
【3】无缓冲channel
无缓冲的通道(unbuffered channel)是指在接收前没有能力保存任何值的通道
这种类型的通道要求发送goroutine和接收goroutine同时准备好,才能完成发送和接收操作。如果两个goroutine没有同时准备好,通道会导致限制性发送或接收操作的goroutine阻塞等待。
这种通道进行发送和接收的交互行为为本身就是同步的。其中任意一个操作都无法离开另一个操作单独存在。
无缓冲的channel创建格式:
make(chan Type) //等价于make(chan Type, 0)
如果没有指定缓冲区容量,那么该通道就是同步的,因此会阻塞到发送者准备好发送和接收者准备好接收。
package main import ( "fmt" "time" ) func main() { //创建一个无缓冲channel ch := make(chan int, 0) //len(ch)缓冲区剩余数据个数 fmt.Printf("len(ch) = %d, cap(ch) = %d\n", len(ch), cap(ch)) //创建协程 go func() { for i := 0; i < 3; i++ { fmt.Println("子协程:i = ", i) ch <- i //往channel写内容 } }() //延迟 time.Sleep(2 * time.Second) for i := 0; i < 3; i++ { num := <-ch //从管道中读数据,没有内容前,阻塞 fmt.Println("num = ", num) } }
输出:
没有按照先i后num的原因是num还没来得及打印i就抢先打印了。
【4】有缓冲channel
有缓冲的通道(buffered channel)是一种在被接收前能存储一个或者多个值的通道
这种类型的通道并不强制要求goroutine之间必须同时完成发送和接收。通信会阻塞发送和接收动作的条件也会不同。只有在通道中没有要接收的值时,接收动作才会阻塞。只有在通道没有可用缓冲区容纳被发送的值时,发送动作才会阻塞。
这导致有缓冲的通道和无缓冲的通道之间的一个很大的不同:无缓冲的通道保证进行发送和接收的goroutine会在同一时间进行数据交换,有缓冲的通道没有这个保证。
package main import ( "fmt" "time" ) func main() { //创建一个有缓冲channel ch := make(chan int, 3) //ch := make(chan int, 1) //len(ch)缓冲区剩余数据个数 fmt.Printf("len(ch) = %d, cap(ch) = %d\n", len(ch), cap(ch)) //创建协程 go func() { for i := 0; i < 3; i++ { ch <- i //往channel写内容 fmt.Printf("子协程[%d]:len(ch) = %d, cap(ch) = %d\n", i, len(ch), cap(ch)) } }() //延迟 time.Sleep(2 * time.Second) for i := 0; i < 3; i++ { num := <-ch //从管道中读数据,没有内容前,阻塞 fmt.Println("num = ", num) } }
输出:
缓冲区大小为3:
缓冲区大小为1:
【5】关闭channel
package main import ( "fmt" ) func main() { //创建一个无缓冲channel ch := make(chan int, 0) //创建一个goroutine go func() { for i := 0; i < 5; i++ { ch <- i //往通道写数据 } close(ch) //关闭通道 }() for { //如果为true说明管道没有关闭 if num, ok := <-ch; ok == true { fmt.Println("num = ", num) } else { //管道关闭 break } } }
输出:
【6】通过range遍历channel内容
package main import ( "fmt" ) func main() { //创建一个无缓冲channel ch := make(chan int, 0) //创建一个goroutine go func() { for i := 0; i < 5; i++ { ch <- i //往通道写数据 } close(ch) }() for num := range ch { fmt.Println("num = ", num) } }
输出:
【7】单向管道
默认情况下,通道是双向的,也就是,既可以往里面发送数据也可以从里面接收数据。
但是,我们经常见一个通道作为参数进行传递而值希望对方是单向使用的,要么只让它发送数据,要么只让它接收数据,这时候我们可以指定通道的方向。
- chan<-表示数据进入管道,要把数据写入管道,对于调用者就是输出
- <-chan表示数据从管道出来,对于调用者就是得到管道的数据,当然就是输入。
单向channel的特性验证:
package main func main() { //创建一个channel,双向的 ch := make(chan int) //双向channel能隐式转换为单向channel var writeCh chan<- int = ch //只能写,不能读 var readCh <-chan int = ch //只能读,不能写 writeCh <- 666 //写 <-readCh //读 //单向无法转化为双向 }
单向channel的应用:
package main import ( "fmt" ) //此管道只能写不能读 func producter(out chan<- int) { for i := 0; i < 10; i++ { out <- i * i } close(out) } //此管道只能读不能写 func consumer(in <-chan int) { for num := range in { fmt.Println("num = ", num) } } func main() { //创建一个双向通道 ch := make(chan int) //生产者,生产数字,写入channel go producter(ch) //channel传参,引用传递 //消费者,从channel读取内容,打印 consumer(ch) }
输出:
4.定时器
- Timer是一个定时器,代表未来的一个单一事件,你可以告诉timer你要等待多长时间,它提供一个channel,在将来的那个时间那个channel提供了一个时间值。
package main import ( "fmt" "time" ) func main() { //创建一个定时器,设置时间为2s,2s后,往time通道写内容(当前时间) //timer只会执行一次 timer := time.NewTimer(2 * time.Second) fmt.Println("当前时间:", time.Now()) //2s后,往timer.C写数据,有数据后,就可以读取 t := <-timer.C fmt.Println("t = ", t) }
输出:
通过timer实现延时:
package main import ( "fmt" "time" ) func main() { //延时两秒后打印一句话 /* 下面两句等价于time.Sleep(2*time.Second) 也等价于<-time.After(2*time.Second) //定时两秒,阻塞两秒,2s后产生一个事件,往channel写内容 */ timer := time.NewTimer(2 * time.Second) <-timer.C fmt.Println("时间到") }
输出:
停止定时器:
package main import ( "fmt" "time" ) func main() { timer := time.NewTimer(3*time.Second) go func() { <-timer.C fmt.Println("子协程可以打印了,因为定时器的时间到") }() timer.Stop()//停止定时器 for { } }
重置定时器:
package main import ( "fmt" "time" ) func main() { timer := time.NewTimer(3 * time.Second) timer.Reset(1 * time.Second) //重置计时器 <-timer.C fmt.Println("时间到") }
输出:
- Ticker是一个定时触发的计时器,他会以一个间隔(interval)往channel发送一个事件(当前时间),而channel的接收者可以以固定的时间间隔从chnanel中读取事件。
package main import ( "fmt" "time" ) func main() { //创建定时器,每隔1秒后,定时器就会给channel发送一个时间(当前时间) ticker := time.NewTicker(2 * time.Second) i := 0 go func() { for { i++ <-ticker.C fmt.Println("时间到") if i > 5 { ticker.Stop() //停止定时器 } } }() for { } }
输出:
5.select
Go里面提供了一个关键字select,通过select可以监听channel上的数据流动。
Select的用法与switch语言非常类似,由select开始一个新的选择块,每个选择条件由case语句来描述。与switch语句可以选择任何人可使用相等的比较条件相比,select有比较多的限制,其中最大的一条限制就是每个case语句里必须有一个IO操作。在一个select语句中,GO语言会按顺序从头至尾评估每一个发送和接收的语句。如果其中的任意一个语句可以继续执行(即没有被阻塞),那么就从那些可以执行的语句中任意选择一条来使用。
如果没有任意一条语句可以执行(即所有的通道都被阻塞),那么有两种情况:
- 如果给出了default语句,那么就会执行default语句,同时程序的执行会从select语句后的语句中恢复。
- 如果没有default语句,那么select语句将被阻塞,直到至少有一个可以进行下去。
package main import ( "fmt" ) func fibonacci(ch chan<- int, quit <-chan bool) { x, y := 1, 1 for { //监听channel数据的流动 select { case ch <- x: x, y = y, x+y case flag := <-quit: fmt.Println("flag = ", flag) return } } } func main() { ch := make(chan int) //数字通信 quit := make(chan bool) //程序是否结束 //消费者,从channel读取内容 //新建协程 go func() { for i := 0; i < 8; i++ { num := <-ch fmt.Println(num) } //可以停止 quit <- true }() //生产者,产生数字,写入channel fibonacci(ch, quit) }
输出:
有时候会出现goroutine阻塞的情况,那么我们如何避免整个程序进入阻塞的情况呢?我们可以利用select来设置超时,通过如下方式实现:
package main import ( "fmt" "time" ) func main() { ch := make(chan int) flag := make(chan bool) go func() { for { select { case v := <-ch: fmt.Println(v) case <-time.After(5 * time.Second): fmt.Println("timeout") flag <- true } } }() <-flag fmt.Println("程序结束") }
输出: