美文网首页程序员
golang goroutine协程运行机制及使用详解

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

作者: 臣以君纲 | 来源:发表于2019-03-03 19:05 被阅读7次

    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);
    }
    

    打印结果

    5551600088800499999991117777777742222220000044444444888888888999
    9666665111177777777777777777777777777333333333333333399999999999
    999999999999999999999999999999444442224444444488888888222222222
    20888886666666655555555555444011111111111111000000000999999555555
    5554444444000077777666666311111197777778888222277777753333444444
    9999997777772222000077774444444444444444444
    

    可以看到,完全是随机的,打印哪个取决于调度器对协程的调度,
    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核数的最大值,并返回之前的值。

    相关文章

      网友评论

        本文标题:golang goroutine协程运行机制及使用详解

        本文链接:https://www.haomeiwen.com/subject/cqgpuqtx.html