[golang note] 协程基础

协程概念

---

       √ 协程通常称为coroutine，在golang中称为goroutine。

       √ 协程本质上是一种用户态线程，它不需要操作系统来进行抢占式调度，在实际实现中寄存在线程之中。

       √ 协程系统开销极小，可有效提高单个线程的任务并发性，从而避免使用多线程。而且使用协程编程简单，结构清晰。缺点就是需要编程语言的支持，如果不支持，则需要用户在程序中自行实现调度器。

goroutine

---

       √ goroutine是golang中的轻量级线程实现，由go runtime管理。

• goroutine使用语法

// 定义协程函数
func MyRoutineFunction(参数列表) (返回值列表) {
    // 函数体
}

// 启动协程
go MyRoutineFunction(参数列表)

       √ 启动一个goroutine使用go关键字，go是golang中最重要的关键字，因此这个语言也是以这个关键字命名。

       √ 在一个函数前加上go关键字调用，这次调用就会在一个新的goroutine中并发执行，开启goroutine的线程将继续执行。

       √ 当被go调用的函数返回时，这个goroutine也自动结束了。如果这个函数有返回值，那么这个返回值会被丢弃。

       √ golang程序从main()函数开始执行，当main()函数返回时，程序结束且不等待其他goroutine结束。

• goroutine使用示例

package main

import (
    "fmt"
    "time"
)

func Add(x, y int) {
    z := x + y
    fmt.Println(z)
}

func main() {
    for i := 0; i < 10; i++ {
        go Add(i, i)
    }

    fmt.Println("main goroutine finished!")
    time.Sleep(3 * time.Second)
}

       程序运行两次的结果如下：

       可以看出goroutine看上去的确是并发执行，结果具有不确定性。

并发与并行

---

• 概念

      

       √ 两个队列，一个Coffee机器，那是并发。

       √ 两个队列，两个Coffee机器，那是并行。

• golang并发与并行

▶  并发执行

       √ 如果在单核cpu情况下，golang所有的goroutine只能在一个线程里跑 。

       √ 如果当前goroutine不发生阻塞，它是不会让出cpu时间给其他goroutine，除非调用runtime.Gosched()主动让出时间片。

       √ 如果当前goroutine发生阻塞，它会主动让出cpu时间给其他goroutine执行。

       √ golang的runtime包是goroutine的调度器，其中使用runtime.GOMAXPROCS(n)可以控制使用cpu核数。

▪ 例子一

package main

import "fmt"
import "time"
import "runtime"

func loop() {
    fmt.Println("loop starts!")
    for i := 0; i < 10; i++ {
        fmt.Printf("%d ", i)
    }
    fmt.Println()
}

func main() {
    runtime.GOMAXPROCS(1) // 强制使用1个cpu

    go loop()
    go loop()

    time.Sleep(3 * time.Second)
}

       运行结果如下：

▪ 例子二

package main

import (
    "fmt"
    "runtime"
    "time"
)

func Add(x, y int) {
    z := x + y
    fmt.Println(z)
}

func main() {
    runtime.GOMAXPROCS(1) // 强制使用1个cpu

    go Add(0, 0)
    go Add(1, 1)
    go Add(2, 2)
    go Add(3, 3)
    go Add(4, 4)
    go Add(5, 5)
    go Add(6, 6)
    go Add(7, 7)
    go Add(8, 8)
    go Add(9, 9)

    fmt.Println("main goroutine finished!")
    time.Sleep(3 * time.Second)
}

       运行结果如下：

▶  并行执行

       √ 默认情况下，golang是开启多核的，因此一开始的示例中的输出就是无序的。

       √ 我们也可以告诉golang我们允许同时最多使用核数。

▪ 例子一

package main

import "fmt"
import "time"
import "runtime"

func loop() {
    fmt.Println("loop starts!")
    for i := 0; i < 10; i++ {
        fmt.Printf("%d ", i)
    }
    fmt.Println()
}

func main() {
    runtime.GOMAXPROCS(2)

    go loop()
    go loop()
    go loop()
    go loop()

    time.Sleep(3 * time.Second)
}

       多运行几次，可以得到结果：