golang goroutine协程运行机制及使用详解

Go（又称 Golang ）是 Google 开发的一种 静态 强类型 、编译型、并发型，并具有垃圾回收功能的 编程语言 。Go于2009年正式推出，国内各大互联网公司都有使用，尤其是七牛云，基本都是golang写的，

传闻 Go 是为并发而生的语言，运行速度仅比c c++慢一点，内置协程（轻量级的线程），说白了协程还是运行在一个线程上，由调度器来调度线程该运行哪个协程，也就是类似于模拟了一个操作系统调度线程，我们也知道， 其实多线程说白了也是轮流占用cpu，其实还是顺序执行的 ，协程也是一样，他也是轮流获取执行机会，只不过他获取的是线程， 但是如果cpu是多核的话，多线程就能真正意义上的实现并发 同时，如果GO执行过程中有多个线程的话，协程也能实现真正意义上的并发执行，所以， 最理想的情况，根据cpu核数开辟对应数量的线程，通过这些线程，来为协程提供执行环境

当我们在开发网络应用程序时，遇到的瓶颈总是在io上，由此出现了多进程，多线程，异步io的解决方案，其中异步io最为优秀，因为他们在不占用过多的资源情况下完成高性能io操作，但是异步io会导致一个问题，那就是回调地狱，node js之前深受诟病的地方就在于此，后来出现了async await这种方案，真正的实现了同步式的写异步，其实Go的协程也是这样，有人把goroutine叫做纤程，认为node js的async await才是真正的协程，对此我不做评价，关于goroutine的运行机制本文不讲，大家可以看 这篇 博文，讲的很生动，本文主要对goroutine的使用进行讲解，如果大家熟悉node js的async await或者c#的async（其实node js就是学习的c#的async await），可以来对比一下两者在使用上的不同，从而对协程纤程的概念产生进一步的了解

在golang中开辟一个协程非常简单，只需要一个go关键字

package main
  
import (
        "fmt"
        "time"
)


func main(){
        for i := 0;i<10;i++{
                go func(i int){
                        for{
                                fmt.Printf("%d",i);
                           }
                }(i)
        }
        time.Sleep(time.Millisecond);
}

打印结果

可以看到，完全是随机的，打印哪个取决于调度器对协程的调度，

goroutine相比于线程，有个特点，那就是非抢占式，如果一个协程占据了线程，不主动释放或者没有发生阻塞的话，那么永远不会交出线程的控制权，我们举个例子来验证下

package main
  
import (
       "time"
)
func main(){
        for i := 0;i<10;i++{
                go func(i int){
                        for{
                                i++                                
                          }
                }(i)
        }
        time.Sleep(time.Millisecond);
}

这段程序在执行后，永远不会退出，并且占满了cpu，原因就是goroutine中，一直在执行i++，没有释放，而一直占用线程，当四个线程占满之后，其他的所有goroutine都没有执行的机会了，所以本该一秒钟后就退出的程序一直没有退出，cpu满载再跑，但是为什么前面例子的Printf没有发生这种情况呢？是因为Printf其实是个io操作，io操作会阻塞，阻塞的时候goroutine就会自动的释放出对线程的占有，所以其他的goroutine才有执行的机会，除了io阻塞，golang还提供了一个api，让我们可以手动交出控制权，那就是Gosched()，当我们调用这个方法时，goroutine就会主动释放出对线程的控制权

package main
  
import (
       "time"
      "runtime"
)
func main(){
        for i := 0;i<10;i++{
                go func(i int){
                        for{
                                i++;
                                runtime.Gosched();                                
                          }
                }(i)
        }
        time.Sleep(time.Millisecond);
}

修改之后，一秒钟之后，代码正常退出

常见的触发goroutine切换，有一下几种情况

1、I/O,select

2、channel

3、等待锁

4、函数调用（是一个切换的机会，是否会切换由调度器决定）

5、runtime.Gosched()

说完了goroutine的基本用法，接下来我们说一下goroutine之间的通信，Go中通信的理念是“不要通过共享数据来通信，而是通过通信来共享数据“，Go中实现通信主要通过channel，它类似于unix shell中的双向管道，可以接受和发送数据，

我们来看个例子，

package main
  
import(
        "fmt"
        "time"
)

func main(){
        c := make(chan int)
        go func(){
           for{
                n := <-c;
                fmt.Printf("%d",n)
              }
        }()

        c <- 1;
        c <- 2;
        time.Sleep(time.Millisecond);


}

打印结果为 12 ,我们通过make来创建channel类型，并指明存放的数据类型，通过 <- 来接收和发送数据， c <- 1 为向channel c发送数据1， n := <-c; 表示从channel c接收数据，默认情况下，发送数据和接收数据都是阻塞的，这很容易让我们写出同步的代码，因为阻塞，所以会很容易发生goroutine的切换，并且，数据被发送后一定要被接收，不然会一直阻塞下去，程序会报错退出，

本例中，首先向c发送数据1，main goroutine阻塞，执行开辟的协程，从而读到数据，打印数据，然后main协程阻塞完成，向c发送第二个数据2，开辟的协程还在阻塞读取数据，成功读取到数据2时，打印2，一秒钟后，主函数退出，所有goroutine销毁，程序退出

我们仔细看这份代码，其实有个问题，在开辟的goroutine中，我们一直再循环阻塞的读取c中的数据，并不知道c什么时候写入完成，不再写入，如果c不再写入我们完全可以销毁这个goroutine，不必占有资源，通过close api我们可以完成这一任务，

package main
  
import (
        "fmt"
        "time"
)

func main(){
        c := make(chan int);
        go func(){
            for{
                p,ok := <-c;
                if(!ok){
                        fmt.Printf("jieshu");
                        return
                }
                fmt.Printf("%d",p);
               }
        }()
        for i := 0;i<10;i++{
                c<-i
        }
        close(c);
}

当我们对channel写入完成后，可以调用 close 方法来显式的告诉接收方对channel的写入已经完毕，这是，在接收的时候我们可以根据接收的第二个值，一个boolean值来判断是否完成写入，如果为false的话，表示此channel已经关闭，我们没有必要继续对channel进行阻塞的读，

除了判断第二个boolean参数，go还提供了range来对channel进行循环读取，当channel被关闭时就会退出循环，

package main
  
import (
        "fmt"
        "time"
)

func main(){
        c := make(chan int);
        go func(){
        //    for{
        //      p,ok := <-c;
        //      if(!ok){
        //              fmt.Printf("jieshu");
        //              return
        //      }
                for p := range c{
                        fmt.Printf("%d",p);
                }
                fmt.Printf("jieshu");
        //   }
        }()
        for i := 0;i<10;i++{
               c<-i
        }
        close(c);
        time.Sleep(time.Millisecond);

}

两种方式打印的都是 123456789jieshu

另外，通过Buffered Channels我们可以创建带缓存的channel，使用方法为创建channel时传入第二个参数，指明缓存的数量，

package main

import "fmt"

func main() {
    c := make(chan int, 2)//修改2为1就报错，修改2为3可以正常运行
    c <- 1
    c <- 2
    fmt.Println(<-c)
    fmt.Println(<-c)
}

例子中，我们创建channel时，传入参数2，便可以存储两个两个数据，前两个数据的写入可以无阻塞的，不需要等待数据被读出，如果我们连续写入三个数据，就会报错，阻塞在第三个数据的写入出无法进行下一步

最后，我们说一下select，这个和操作系统io模型中的select很像，先执行先到达的channel我们看个例子

package main
  
import (
        "fmt"
        "time"
)

func main(){

        c := make(chan int);
        c2:= make(chan int);

        go func(){
         for{
                select{
                        case p := <- c : fmt.Printf("c:%d\n",p);
                        case p2:= <- c2: fmt.Printf("c2:%d\n",p2);
                }
            }
        }()

        for i :=0;i<10;i++{
                go func(i int){
                        c <- i
                }(i)
                go func (i int){
                        c2 <-i
                }(i)
        }
        time.Sleep(5*time.Millisecond);
}

打印结果为

c:0
c2:1
c:1
c:2
c2:0
c:3
c:4
c:5
c:7
c2:2
c:6
c:8
c:9
c2:3
c2:5
c2:4
c2:6
c2:7
c2:8
c2:9

可以看到，c和c2的接收完全是随机的，谁先接收到执行谁的回调，当然这不仅限于接收，发送数据时也可以使用select函数，另外，和switch语句一样，golang中的select函数也支持设置default，当没有接收到值的时候就会执行default回调，如果没有设置default，就会阻塞在select函数处，直到某一个发送或者接收完成。

golang中 goroutine的基本使用就是这些，大家可以根据上面goroutine运行机制的文章和本文一起来体会golang的运行过程。

补充一个runtime包的几个处理函数

• Goexit
  退出当前执行的goroutine，但是defer函数还会继续调用
• Gosched
  让出当前goroutine的执行权限，调度器安排其他等待的任务运行，并在下次某个时候从该位置恢复执行。
• NumCPU
  返回 CPU 核数量
• NumGoroutine
  返回正在执行和排队的任务总数
• GOMAXPROCS
  用来设置可以并行计算的CPU核数的最大值，并返回之前的值。