美文网首页Go基础系列随笔-生活工作点滴
14 Go并发编程(一):协程 —— Go并发的基本运行单元

14 Go并发编程(一):协程 —— Go并发的基本运行单元

作者: GoFuncChan | 来源:发表于2019-07-06 00:04 被阅读13次

    Go协程

    1.什么是goroutine?

    Go在语言级别原生支持并发操作,这在现代众多基于线程并发的其他语言来看是比较鹤立鸡群的。在Go中最基本的并发任务单元是一种称为goroutine的东西,我们把它叫做协程或go程,其开一个并发任务简单到令人发指,只需go关键字,就能让一个函数成为并发任务。

    示例:

    //启动go程并发
    func BaseGoroutine01() {
        //开辟一条协程
        go func() {
            fmt.Println("这里是独立开辟的协程打印的!!!")
        }()
    
        //开辟十条协程
        for i := 1; i <= 10; i++ {
            go func(num int) {
                fmt.Println("这里由协程", num, "打印!!!")
            }(i)
        }
    
        //把一个命名函数作为协程运行
        go goroutineFunc()
        fmt.Println("这里由父协程打印!!!")
    
        //父协程必须留有足够长时间让子协程运行完,暂时用睡眠
        time.Sleep(time.Second)
    
    }
    
    func goroutineFunc() {
        for i := 1; i <= 10; i++ {
            fmt.Println(i)
        }
    }
    

    go的协程有如下几个特点:

    • Go的协程是一个轻量级的线程,多个协程可能运行在一个或者多个线程上;
    • Go的协程是非抢占式多任务处理,需要由协程主动交出控制权,这与其他抢占型的线程并发方式不同,这种非抢占式设计减少了许多cpu调度切换的开销;
    • Go的协程是一个虚拟机层面的多任务处理,它基于Go的并发调度器,其调度是go运行时自动管理的,对用户不可见,用户只需管理业务层面的并发即可。
    • Go中所有的调用栈都是一个协程,main()函数就是主协程,如无开辟其他协程所有任务都在主协程运行。

    然而,go的协程虽然号称能开百万级,但也不是无节制的是乱开线程,其也是有一些规则甚至是陷阱的,下面我们来了解一些go的协程特性及用法:

    2.go协程特性:父死子随

    父协程没有阻塞的执行完,程序结束,子协程无论有无执行完都会结束。

    
    func BaseGoroutine02() {
        go func() {
            for i := 1; i <= 10; i++ {
                fmt.Println("子协程输出", i)
                time.Sleep(time.Second)
            }
        }()
    
        //父协程只存活5s
        for i := 1; i <= 5; i++ {
            fmt.Println("父协程输出", i)
            time.Sleep(time.Second)
        }
    
    }
    
    3. go协程特性:出让协程资源

    go的协程是非抢占式的,占有cpu资源的协程如无主动让出,其他协程只能等待:使用runtime.Gosched()进行控制

    func BaseGoroutine03() {
    
        for i := 1; i <= 10; i++ {
            go func(n int) {
    
                //出让奇数协程资源
                if n%2 == 1 {
                    //这里使用runtime包控制协程的cpu资源让出
                    runtime.Gosched()
                }
    
                for j := 1; j <= 5; j++ {
                    fmt.Println("第", n, "协程:第", j, "次打印")
                }
    
            }(i)
        }
    
        time.Sleep(time.Second * 3)
    
    }
    
    4.go协程特性:设置并查看可用cpu核心数

    在如今的多核时代,go程序能够充分利用cpu核心数,其runtime包中提供可设置查看可用cpu核心数的函数:runtime.GOMAXPROCS()

    func BaseGoroutine04() {
    
        numCPU := runtime.NumCPU()
        fmt.Println("CPU逻辑核心数:", numCPU)
    
        //GOMAXPROCS设置可同时执行的最大CPU数,并返回先前的设置
        prevNum := runtime.GOMAXPROCS(2)
        fmt.Println("设置CPU核心数为2,设置前为", prevNum)
    
    }
    
    5.go协程特性:协程退出

    使用runtime.Goexit()可让协程退出,父协程和子协程各自退出的后果不同,子协程退出后提前执行defer,非善终(协程不会正常返回),父协程退出会令子协程失去牵制,主从皆死程序崩溃。

    //子协程退出
    func BaseGoroutine05() {
        go func() {
            for i := 1; i <= 5; i++ {
                if i == 3 {
                    fmt.Println("子协程打印到3,协程退出!")
                    runtime.Goexit()
                }
                fmt.Println("子协程输出", i)
                time.Sleep(time.Second)
            }
        }()
    
        for i := 1; i <= 10; i++ {
            fmt.Println("主协程打印", i)
            time.Sleep(time.Second)
        }
    }
    
    6.go协程特性:协程间按调度器队列执行,公平使用资源

    非抢占式的并发模型不会主动占有cpu资源,开启协程后其会在调度器中的协程队列排队,除非别人出让资源,否则按队列执行,关于Go的并发调度模型会另开专题讨论。

    //协程简公平使用资源
    func BaseGoroutine06() {
        go func() {
            for i := 1; i <= 10; i++ {
                fmt.Println("协程1:自己排队!")
                time.Sleep(time.Nanosecond)
            }
        }()
    
        go func() {
            for i := 1; i <= 10; i++ {
                fmt.Println("协程2:自己排队!")
                time.Sleep(time.Nanosecond)
            }
        }()
    
        time.Sleep(time.Second)
    
    }
    

    相关文章

      网友评论

        本文标题:14 Go并发编程(一):协程 —— Go并发的基本运行单元

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