14 Go并发编程（一）：协程 —— Go并发的基本运行单元

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 main() {
    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)

}