聽 聽 聽 聽在写该文之前一直犹豫,是把Go的并发写的面面俱到显得高大尚一些,还是简洁易懂一些?今天看到一个新员工在学习Java,突然间想起第一次接触Java的并发时,被作者搞了一个云里雾里,直到现在还有阴影,所以决定本文从简。哈哈,说笑了,言归正传。
聽 聽 聽 聽Go的并发真的很简单,所以本文不罗嗦进程、线程、协程、信号量、锁、调度、时间片等乱七八糟的东西,因为这些不影响您理解Go的并发。先看一个小例子:
package main import "fmt" func Add(i, j int) { 聽 聽 聽 聽 sum := i + j 聽 聽 聽 聽 fmt.Println(i, " + ", j, " = ", sum) } func main() { 聽 聽 聽 聽 for i := 0; i < 10; i++ { 聽 聽 聽 聽 聽 聽 聽 聽Add(i, i) 聽 聽 聽 聽 } } |
这个例子很简单吧,说白了就是计算0+0、1+1、2+2、3+3、.......、9+9之和,并打印出来,运行结果显而易见:
这里没有使用并发呀,好吧,为了提升计算效率,在main的for循环中使用并发,把代码修改如下:
package main import "fmt" func Add(i, j int) { 聽 聽 聽 聽 sum := i + j 聽 聽 聽 聽 fmt.Println(i, " + ", j, " = ", sum) } func main() { 聽 聽 聽 聽 for i := 0; i < 10; i++ { 聽 聽 聽 聽 聽 聽 聽 聽go聽Add(i, i) 聽 聽 聽 聽 } } |
没有花眼吧,前面加了一个go,这就并发了?
嗯,这就并发了。
在方法Add()之前增加了一个关键字go,相当于告诉Go编译器启动一个goroutine,然后把Add()方法放到goroutine中执行。
什么是goroutine?
有人把它翻译为协程,说实话挺反感的,有些单词还是不要翻译为好,比如Context,经常写Web程序的人会遇到,有人把它翻译为上下文;再如payload,经常做渗透的人会使用,怎么翻译好呢?还是不翻译了吧。
该怎么理解goroutine?
如上图所示,main()方法所在的goroutine上又创建了10个goroutine,每个goroutine各自跑一个Add()方法
OK,运行一下该程序,结果如下:
咦,怎么都没有,说好的运行结果呢?
聽 聽 聽 聽这是因为main()所在的goroutine创建10个goroutine后,它里面的逻辑已执行完,那么main()就退出了,它根本就不管这10个goroutine的死活。从结果也能看出,当main()退出时,这10个goroutine没有一个执行完,所以结果什么都没有打印。
如何解决这个问题呢?
一种比较容易想到的但又比较垃圾的解决办法是:“让main()等一会儿”,下面我们修改一个这个程序
package main import ( 聽 聽 聽 聽"fmt" 聽 聽 聽 聽"time" ) func Add(i, j int) { 聽 聽 聽 聽 sum := i + j 聽 聽 聽 聽 fmt.Println(i, " + ", j, " = ", sum) } func main() { 聽 聽 聽 聽 for i := 0; i < 10; i++ { 聽 聽 聽 聽 聽 聽 聽 聽go Add(i, i) 聽 聽 聽 聽 } 聽 聽 聽 聽 time.Sleep(time.Second * 3) 聽// main()所在goroutine休息3秒钟 } |
首先引入"time"这个包,然后调用time.Sleep()方法,让main()所在goroutine等3s,等其它10个goroutine都运行完,这种解决办法就是“马儿你慢些跑呀慢些跑” :)
运行一下结果:
可能您会问,为何要等3秒钟而不是2秒钟?
我只能学着印度老外,一边摇头一边微笑地告诉您,我是蒙的,因为我也不知道确切地等多长时间,所以是一种垃圾的解决办法。
那有没有一种通知机制呢?当一个goroutine执行完毕后,就告诉主goroutine(即main()方法所在的goroutine):“嘿,哥们,我执行完了,你想干嘛就干嘛吧!”
有,这就是Go语言的亮点,十分耀眼的一个亮点:channel
什么是channel?
说白了就是一个通道(建议还是不翻译的为好),一个goroutine执行完毕后,就告诉主goroutine,I'm over!怎么告诉呢?就是向channel中写一个数据。
怎么向channel中写一个数据呢?
OK,follow me,要想写一个数据到channel则必须有一个channel不是?所以:
(1)建立一个channel
【备注】:所谓channel也是一种Go的类型,与int、float64、string、bool、struct、slice、map等同等地位
var ch chan int 聽 聽 聽 聽 聽聽// 声明一个变量为ch,它的类型为chan类型,这个channel里面可以存放int型的值
ch = make(chan int)聽 // 使用make关键字初始一个长度为0的通道
当然声明和初始化可以一块来
var ch chan int = make(chan int)
(2)向channel中写一个数据
ch <- 1
就这么简单,使用符号”<-“,前面声明了channel的类型为int ,所以就把1写入ch;若声明channel类型为bool,就可以把布尔值写入channel,即ch <- true
(3)从channel中读数据
<- ch
嗯,还是这么简单
无论写还是读都是用符号”<-“,就看<-后面是谁
OK,既然知道有channel这东东了,我们修改一下上面的程序:
package main import ( 聽 聽 聽 聽 "fmt" 聽 聽 聽 聽聽// "time"聽 聽// 删除掉time包 ) var ch chan int = make(chan int) 聽 聽 // 初始化一个类型为channel的变量ch,其中channel里面放int型数据 func Add(i, j int) { 聽 聽 聽 聽 sum := i + j 聽 聽 聽 聽 fmt.Println(i, " + ", j, " = ", sum) 聽 聽 聽 聽 ch <- i 聽 // 这个方法执行完,意味着方法所属的goroutine即将退出,就告诉主goroutine,I'm完事了 } func main() { 聽 聽 聽 聽 for i := 0; i < 10; i++ { 聽 聽 聽 聽 聽 聽 聽 聽go Add(i, i) 聽 聽 聽 聽 } 聽 聽 聽 聽聽/* 聽 聽 聽 聽 聽* 由于有10个goroutine,所以从channel中读10次 聽 聽 聽 聽 聽* 这10个goroutine都告诉主gorouinte说完事了,那么主gorouinte也就退出了 聽 聽 聽 聽 聽*/ 聽 聽 聽 聽 for i := 0; i < 10; i++ { 聽 聽 聽 聽 聽 聽 聽 聽fmt.Println("i=", <-ch) 聽 聽 聽 聽 } 聽聽 聽 聽 聽 聽聽// time.Sleep(time.Second * 3)聽聽 聽// 不用这种机制了,留着也没有用 } |
运行结果如下:
目的达到了,我好人做到底,再解释一下:
可以这样理解,有10个厨师1个端菜工,这10个厨师各自做各自的菜,做完之后就放到channel,这个端菜工就从channel中取菜。当channel中没有菜时,端菜工就一直等待直到有菜为止;厨师做好一个菜后,发现channel中没有菜,就把自己的菜放到channel中,若发现channel在有菜还没有端正,厨师就拿着自己的菜一直等到channel中的菜被端菜工端走后再把自己的菜放进去。
可能您又要说了,这种channel很类似同步操作,这个channel只能放一个菜,端菜工端一个菜;channel中没有菜端菜工等待;channel中有菜厨师等待。效率不高呀。
好吧,Go设计师已提前为您想好处理办法了,即这个channel可以放10个菜,只要这个channel还没有放满10个菜,厨师就可以向上面放,这样厨师就不用等待了。剩下的就是端菜工要提高自己的工作效率了。
怎么放10个菜?
var ch chan int = make(chan int,10)
OK,搞定!代码如下:
package main import ( 聽 聽 聽 聽"fmt" 聽 聽 聽 聽// "time" ) var ch chan int = make(chan int, 10) func Add(i, j int) { 聽 聽 聽 聽 sum := i + j 聽 聽 聽 聽 fmt.Println(i, " + ", j, " = ", sum) 聽 聽 聽 聽 ch <- i } func main() { 聽 聽 聽 聽 for i := 0; i < 10; i++ { 聽 聽 聽 聽 聽 聽 聽 聽 go Add(i, i) 聽 聽 聽 聽 } 聽 聽 聽 聽 for i := 0; i < 10; i++ { 聽 聽 聽 聽 聽 聽 聽 聽 fmt.Println("i=", <-ch) 聽 聽 聽 聽 } 聽 聽 聽 聽 // time.Sleep(time.Second * 3) } |
运行结果如下:
仔细看,再仔细看,看出什么东西来了没有?若没有,请与上一个运行结果对比着看 :)
还是没有看来?
没有发现这两个基本上是一模一样的吗?除了运行程序所花的时间不同之外!
从运行时间上来看,好像效率提升了一些,这是因为厨师不用等待了,一旦指明了channel的容量,相对于厨师来说就变成异步的了;没有指明channel容量,相对于厨师来说就是同步的。
同步异步不是我想让您观察的重点,您难道没有发现0+0、1+1、2+2、3+3、......、9+9,这个顺序太正常了吗?若真正并发的话,这个顺序肯定是乱的!
看一下我电脑信息:
好呆CPU也是四核的,并发的顺序是这么的正常,太不可思议了 :)
好吧,我再解开这谜团吧
我用的Go版本是1.4,可以在命令窗口中执行go version查看。由于Go语言1.4版本对多核的处理还没有做太多的改进,据说1.5版本有突破,后面可以关注一下,所以在这个版本还是使用的一个核。对于单核CPU进程、线程在执行的过程中,系统会把运行的CPU强行切给另一个进程或线程。
聽 聽 聽 聽有人如果看过其他人的博客、书,都会把goroutine翻译为协程,所谓协程就是用户态的线程,可以这样理解:”一个协程在执行时,系统不会强行切换时间片“。即一个goroutine在执行的过程中,Go语言会让这个goroutine疯狂地执行,直到它运行完为止,再让另外一个gorouinte运行,所以从结果来看运行顺序是固定的。
如果利用多核?
Go语言也提供了一种方式,具体代码如下:
package main import ( 聽 聽 聽 聽 "fmt" 聽 聽 聽 聽 聽// "time" 聽 聽 聽 聽 "runtime" 聽 // 引入runtime包 ) var ch chan int = make(chan int, 10) func Add(i, j int) { 聽 聽 聽 聽 sum := i + j 聽 聽 聽 聽 fmt.Println(i, " + ", j, " = ", sum) 聽 聽 聽 聽 ch <- i } func main() { 聽 聽 聽 聽聽runtime.GOMAXPROCS(runtime.NumCPU()) 聽聽// 让Go使用多个核 聽 聽 聽 聽 for i := 0; i < 10; i++ { 聽 聽 聽 聽 聽 聽 聽 聽 go Add(i, i) 聽 聽 聽 聽 } 聽 聽 聽 聽 for i := 0; i < 10; i++ { 聽 聽 聽 聽 聽 聽 聽 聽 fmt.Println("i=", <-ch) 聽 聽 聽 聽 } 聽 聽 聽 聽 // time.Sleep(time.Second * 3) } |
多运行几次,结果如下:
上面就是Go的并发核心内容,当然还有关于并发的其它内容,如单向写channel、单向读channel、传统并发方式等内容。本文就先写到这里,内容多了不容易消化 :)
本文出自 “青客” 博客,请务必保留此出处http://qingkechina.blog.51cto.com/5552198/1678483
有疑问加站长微信联系(非本文作者)