【Go语言】【16】GO语言的并发

       在写该文之前一直犹豫，是把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之和，并打印出来，运行结果显而易见：

wKiom1WxDbuytM6ZAAB3g9O_6RE137.jpg

这里没有使用并发呀，好吧，为了提升计算效率，在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？

wKiom1WxFNSzzoWGAABCVx7S4ag290.jpg

如上图所示，main()方法所在的goroutine上又创建了10个goroutine，每个goroutine各自跑一个Add()方法

OK，运行一下该程序，结果如下：

wKioL1WyPvPxvZKQAAA6SKx6fxY454.jpg

咦，怎么都没有，说好的运行结果呢？

       这是因为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都运行完，这种解决办法就是“马儿你慢些跑呀慢些跑” ：）

运行一下结果：

wKioL1W0il2j7fDCAACEihWG434218.jpg

可能您会问，为何要等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)    // 不用这种机制了，留着也没有用

}

运行结果如下：

wKiom1W0j0Pywr5YAACuV9q2SiA269.jpg

目的达到了，我好人做到底，再解释一下：

wKiom1W0kT6iWzBaAABBf0JPAyg153.jpg

可以这样理解，有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)

}

运行结果如下：

wKioL1W0lmyg4e6pAAC0isrnOiA330.jpg

仔细看，再仔细看，看出什么东西来了没有？若没有，请与上一个运行结果对比着看 ：）

还是没有看来？

没有发现这两个基本上是一模一样的吗？除了运行程序所花的时间不同之外！

从运行时间上来看，好像效率提升了一些，这是因为厨师不用等待了，一旦指明了channel的容量，相对于厨师来说就变成异步的了；没有指明channel容量，相对于厨师来说就是同步的。

同步异步不是我想让您观察的重点，您难道没有发现0+0、1+1、2+2、3+3、......、9+9，这个顺序太正常了吗？若真正并发的话，这个顺序肯定是乱的！

看一下我电脑信息：

wKioL1W0mP_zj3AJAACAK6QNaAg573.jpg

好呆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)

}

多运行几次，结果如下：

wKioL1W0nP7Dn8CjAADDrRYGui4629.jpg

上面就是Go的并发核心内容，当然还有关于并发的其它内容，如单向写channel、单向读channel、传统并发方式等内容。本文就先写到这里，内容多了不容易消化 ：）

附件：http://down.51cto.com/data/2365954

©著作权归作者所有：来自51CTO博客作者qingkechina的原创作品，如需转载，请注明出处，否则将追究法律责任

G