第九章 goroutine

接下来学习并发编程, 并发编程是go语言最有特色的地方, go对并发编程是原生支持.

goroutine是go中最近本的执行单元

每一个go程序至少有一个goroutine, 那就是主goroutine. 当程序启动时, 他会自动创建. 也就是main方法

main方法也是一个goroutine

 

一. 如何定义一个协程. 

package main

import (
    "fmt"
    "time"
)

func main() {
    for i := 0; i<1000; i++ {
        go func(i int) {
            for   {
                fmt.Printf("goroutine: %d \n", i)
            }
        }(i)
    }

    time.Sleep(time.Second)
}

• 定义协程使用go 关键字.

二. 对goroutine的理解

goroutine和Coroutine比较相似, Coroutine是协程. 其他语言都有这个叫法, 但不是所有语言都支持.

• 协程和线程的区别
  • 线程（Thread）：有时被称为轻量级进程(Lightweight Process，LWP），是程序执行流的最小单元。一个标准的线程由线程ID，当前指令指针(PC），寄存器集合和堆栈组成。另外，线程是进程中的一个实体，是被系统独立调度和分派的基本单位，线程自己不拥有系统资源，只拥有一点儿在运行中必不可少的资源，但它可与同属一个进程的其它线程共享进程所拥有的全部资源。

　　线程拥有自己独立的栈和共享的堆，共享堆，不共享栈，线程的切换一般也由操作系统调度。

• • 协程(Coroutine): 是一种轻量级的"线程", 作用是处理并发任务, 这一点和线程差不多. 协程为什么是轻量级的线程呢?
    • 非抢占式多任务处理, 由协程主动交出控制权. 对比线程, 线程随时都有可能被cpu切换, 线程是抢占式任务处理. 我们是没有控制权的. 任务执行一半, 操作系统有可能就切换到另一个线程去了. 然后还有可能在切换回来. 那么这样切换的时候, 就要考虑保存切换前的状态. 协程不同, 协程是非抢占式的, 什么时候交出控制权, 由协程自己说了算. 因为是非抢占式, 所以不用存储那么多状态, 节省了很多资源
    • 编译器/解释权/虚拟机层面的多任务. 线程是操作系统层面的多任务. 而协程是虚拟机,编译器, 解释器层面的多任务.  在go语言中, 协程可以看作是编译器级别的多任务. 编译器会把一个go func解释为一个协程. 具体在执行上, go语言后面会有一个调度器. (操作系统有一个调度器, go语言还有自己的调度器)
    • 多个协程可以在一个或多个线程上运行. 这是由go调度器决定的

 

1. 非抢占式多任务处理

　　

package main

import (
    "fmt"
    "time"
)

func main() {
    var a [10]int
    for i := 0; i<10; i++ {
        go func(i int) {
            for   {
                a[i] ++
            }
        }(i)
    }

    time.Sleep(time.Second)
    fmt.Println(a)
}

猜一下, 这段代码的运行结果. 结合非抢占式多任务处理

结果是: 这段代码是一个死循环. 当第一次进入到循环体以后. 由于goroutine是非抢占式, 所以第一次循环一直持有, 没有主动释放. 所以, 这段代码的结果是死循环

 

2. 手动交出控制权　　

runtime.Gosched()

这样就可以手动交出控制权, 让其他协程运行

 

3. race condition 数据访问冲突

如果我们在协程中没有传变量i会怎么样呢?

 

 

没错, 报错了. 为什么报错了呢? 我们通过race 来看一下 

go run -race goroutine.go

 

 

可以看到报错的原因是, 同一块空间, 在第七个协程读, 在主协程写. 这样就是有问题的了.

 

接下来分析一下这段代码为什么报错?

package main

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

func main() {
    var a [10]int
    for i := 0; i < 10; i++ {
        go func() {
            for   {
                a[i] ++
                runtime.Gosched()
            }
        }()
    }

    time.Sleep(time.Second)
    fmt.Println(a)
}

程序启动的时候都做了哪些事?

首先. 开了10个协程. i从1遍历到10, 发现10 < 10 , for循环退出了. 但是, 由于协程里面的i是直接饮用的外部的i. 当for循环完成以后, i的值变成10了. 协程里对a[10]进行++, 那自然就会报异常了. 

所以, 为了安全起见, 我们把每一次开协程的时候, 把i带过去.

修改后的

func main() {
    var a [10]int
    for i := 0; i < 10; i++ {
        go func(i int) {
            for   {
                a[i] ++
                runtime.Gosched()
            }
        }(i)
    }

    time.Sleep(time.Second)
    fmt.Println(a)
}

这时候我们在-race一下, 查看是否还有数据访问冲突 

 

 

 

依然有数据访问冲突. 主goroutine在读, 第7个协程在写. 所以这样是有问题的. 这个问题可以通过chan来解决.

4. 子程序是协程的一个特例

 

 我们知道每一个函数都是一个子程序, 子程序是协程的一个speical case, 那怎样才算是一个special case呢?

普通函数和协程的区别

 

　　 1) 普通函数的调用: 首先main方法启动, main方法里调了另一个doWork方法. 当doWork方法都执行完了以后, 在继续回到main方法里, 一次往下执行. 所以普通的函数是单线程.

　　 2) 协程的调用: 协程也是main和doWork,  但是main和doWork之间不是单向的箭头. 中间有一个双向的通道.

　　　　main和dowork之间可以双向的流通. 控制权也可以双向的流通.就像两个线程, 各做各的事情, 中间还可以通信, 控制权可以相互交换.

　　　　那么main和dowork运行在哪里呢?

　　　　可能是一个线程, 也可能是多个线程. 这个事情不需要程序员管了, 调度器可能开一个线程,也可能开两个线程进行执行. 

 

5. go语言的协程

　　

 

 

 

　　1) 首先有一个go语言的进程, 他下面会有一个调度器, 调度器的作用就是调度协程 

　　2) 调度器会分配, 一个协程在一个线程里运行, 也可能是两个协程在一个线程里运行, 也可能是多个协程在一个线程里运行. 这是调度器做的事, 程序员不用管.

6. 协程的定义

　　

 

 

 　　1) 在函数前加go, 就可以交给调度器运行

　　2) 不需要再定义时区分是否是异步函数. 这个是相对于python来说的

　　3) 调度器在合适的点进行切换. 由调度器操作执行, 一般不需要我们来操作

　　4)使用-race来检测数据访问冲突. 这个在上面已经讲过了.

 

7. goroutine可能切换的点

　　

 

 

 

　　调度器在哪些个点有可能切换协程呢?

　　1. I/O, select : I/O和select可能会切换. 之前fmt.Println("")为什么会切换呢? 因为他是一个I/O

　　2) channel

　　3) 等待锁

　　4) 函数调用(有时)

　　5) runtime.Gosched() 手动提供切换的点

总结: 以上只是一个参考, 不能保证遇到这些地方一定切换, 也不能保证其他地方就不切换.

8. 观察启动1000个协程, 我们的系统分配了多少个线程.

package main

import (
    "fmt"
    "time"
)

func main() {
    for i := 0; i < 1000; i++ {
        go func(i int) {
            for   {
                fmt.Printf("hello goroutine: %d \n", i)
            }
        }(i)
    }

    time.Sleep(time.Minute)
}

上面这段程序, 看重点

　　1) 开了1000个协程

　　2) 主线程等待1分钟

 

我们top一下, 看看效果

 

 

红色圈出的是go运行的程序

cpu的占用率是186.6%,  12/3 表示开了多少个线程. 我们发现开了12个线程, 但是最终运行的线程数最多是4个. 原因是我的cpu是4核的.