go语言中的协程详解

协程的特点

1.该任务的业务代码主动要求切换，即主动让出执行权限

2.发生了IO，导致执行阻塞（使用channel让协程阻塞）

与线程本质的不同

C#、java中我们执行多个线程，是通过时间片切换来进行的，要知道进行切换，程序需要保存上下文等信息，是比较消耗性能的

GO语言中的协程，没有上面这种切换，一定是通过协程主动放出权限，不是被动的。

例如：

C# 中创建两个线程

可以看到1和2是交替执行的

Go语言中用协程实现一下

runtime.GOMAXPROCS(1)

这个结果就是 执行了1 在执行2

上述两种方式来进行协程的切换

• 1.该任务的业务代码主动要求切换，即主动让出执行权限

• 2.通过channel进行阻塞

执行的结果一样

后面又继续执行1了

一、Goroutine的并行

package main

import (
　　"fmt"
　　"runtime"
　　"sync"
)

func main() {
　　runtime.GOMAXPROCS(1)
　　var wg sync.WaitGroup
　　wg.Add(3)
　　fmt.Println("Start Goroutines")

　　go func() {
　　　　defer wg.Done()
　　　　for i:=1;i<=10;i++{
　　　　　　fmt.Print("1")
　　　　}
　　}()

　　go func() {
　　　　defer wg.Done()
　　　　for i:=1;i<=10;i++ {
            fmt.Print("2")
　　　　}
　　}()

　　go func() {
　　　　defer wg.Done()
　　　　for i:=1;i<=10;i++ {
　　         fmt.Print("3")
　　　　}
　　}()

　　fmt.Println("等待执行结束")
　　wg.Wait()
}

运行结果

Start Goroutines

等待执行结束

333333333311111111112222222222

（1）runtime.GOMAXPROCS(1) 的作用是什么？

runtime包的GOMAXPROCS 函数。这个函数允许程序更改调度器可以使用的逻辑处理器的数量。如果不想在代码里做这个调用，也可以通过修改和这个函数名字一样的环境变量的值来更改逻辑处理器的数量。

（2）为什么先输出3后输出1和2？

调度器源码中有体现： 有一个队列，还有一个优先执行——即最后一个， 在只有一个逻辑处理器的情况下，先执行优先的那个，再顺序执行队列中的。不过经过各种实验发现这个执行顺序其实是变的，貌似纠结这个顺序也没有什么意思。

（3）WaitGroup 是什么意思？

WaitGroup 是一个计数信号量，可以用来记录并维护运行的goroutine。如果WaitGroup的值大于0，Wait 方法就会阻塞。为了减小WaitGroup 的值并最终释放main 函数，使用defer 声明在函数退出时

调用Done 方法。（defer 有点像C#当中的fianlly）

补充：调度算法中，如果多个goroutine中某个执行过长，此时会将其停止让给其他goroutine继续执行，待到其他都执行完成，在将其进行执行。如下图：G4和G5就进行了切换

如下代码可以验证上面的问题：

package main

import (
    "fmt"
    "runtime"
    "sync"
)

var wg sync.WaitGroup

func main() {
    runtime.GOMAXPROCS(1)

    wg.Add(2)

    fmt.Println("Create Goroutines")
    go printPrime("A")
    go printPrime("B")

    fmt.Println("Waiting To Finish")
    wg.Wait()

    fmt.Println("Terminating Program")
}

func printPrime(prefix string) {
    defer wg.Done()

next:
    for outer := 2; outer < 5000; outer++ {
        for inner := 2; inner < outer; inner++ {
            if outer%inner == 0 {
                continue next
            }
        }
        fmt.Printf("%s:%d\n", prefix, outer)
    }
    fmt.Println("Completed", prefix)
}

printPrime 这个函数作用是查找显示 5000 以内的素数值，这是一个比较耗时的程序。

运行结果：数字比较多，不打印了，但是可以看到结果是A和B两个协程之间的切换。

上面的代码都是设置GOMAXPROCS为1的情况，给每个可用的核心分配一个逻辑处理器

runtime.GOMAXPROCS(runtime.NumCPU())

这样运行第一个程序的结果如下

Start Goroutines
等待执行结束133333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333332111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222

可以看到1、2、3没有什么规律。

二、Goroutine的竞争

什么竞争状态：如果两个或者多个goroutine 在没有互相同步的情况下，访问某个共享的资源，并试图同时读和写这个资源，就处于相互竞争的状态，这种情况被称作竞争状态（race candition）

竞争状态是比较容易出现问题的地方，所以对一个共享资源的读和写操作必须是原子化的，换句话说，同一时刻只能有一个goroutine 对共享资源进行读和写操作。

package main

import (
    "fmt"
    "runtime"
    "sync"
)

var (
    counter int
    wg sync.WaitGroup
)

func main() {
    wg.Add(2)

    go incCounter(1)
    go incCounter(2)

    wg.Wait()
    fmt.Println("Final Counter:", counter)
}

func incCounter(id int) {
    defer wg.Done()
    for count := 0; count < 2; count++ {
        value := counter
        runtime.Gosched()
        value++
        counter = value
    }
}

运行结果：

Final Counter: 2

变量 counter 会进行4 次读和写操作，每个goroutine 执行两次。但是，程序终止时，counter变量的值为2，这是因为两个协程之间产生了竞争，对同一个counter进行读写，下面这个图很好的诠释了为什么最后counter是2

补充：runtime.Gosched()用于让出CPU时间片。

三、使用Goroutine的锁

一种修正代码、消除竞争状态的办法是，使用Go 语言提供的锁机制，来锁住共享资源，

从而保证goroutine 的同步状态。Go 语言提供了传统的同步goroutine 的机制，就是对共享资源加锁。

1、原子函数

使用atomic包来提供对数值类型的安全访问。

package main

import (
    "fmt"
    "runtime"
    "sync"
    "sync/atomic"
)

var (
    counter int64
    wg sync.WaitGroup
)

func main() {
    wg.Add(2)

    go incCounter(1)
    go incCounter(2)

    wg.Wait()

    fmt.Println("Final Counter:", counter)
}

func incCounter(id int) {
    defer wg.Done()
    for count := 0; count < 2; count++ {
        atomic.AddInt64(&counter, 1)
        runtime.Gosched()
    }
}

运行结果

Final Counter: 4

atmoic 包的AddInt64 函数。这个函数会同步整型值的加法，方法是强制同一时刻只能有一个goroutine 运行并完成这个加法操作。当goroutine 试图去调用任何原子函数时，这些goroutine 都会自动根据所引用的变量做同步处理。

另外两个有用的原子函数是LoadInt64 和StoreInt64。这两个函数提供了一种安全地读和写一个整型值的方式。

package main

import (
    "fmt"
    "sync"
    "sync/atomic"
    "time"
)

var (
    shutdown int64
    wg sync.WaitGroup
)

func main() {
    wg.Add(2)

    go doWork("A")
    go doWork("B")

    time.Sleep(1 * time.Second)

    fmt.Println("Shutdown Now")
    atomic.StoreInt64(&shutdown, 1)
    wg.Wait()
}

func doWork(name string) {
    defer wg.Done()

    for {
        fmt.Printf("Doing %s Work\n", name)
        time.Sleep(250 * time.Millisecond)

        // Do we need to shutdown.
        if atomic.LoadInt64(&shutdown) == 1 {
            fmt.Printf("Shutting %s Down\n", name)
            break
        }
    }
}

主协程main函数执行了1秒，然后将shutdown中的值设置为1，A和B的协程中通过读取shutdown是否等于1来判断是否结束协程。

运行结果：

Doing A Work
Doing B Work
Doing A Work
Doing B Work
Doing A Work
Doing B Work
Doing A Work
Doing B Work
Shutdown Now
Shutting A Down
Shutting B Down

2、互斥锁

另一种同步访问共享资源的方式是使用互斥锁（mutex）。互斥锁这个名字来自互斥（mutualexclusion）的概念。互斥锁用于在代码上创建一个临界区，保证同一时间只有一个goroutine 可以执行这个临界区代码

package main

import (
    "fmt"
    "runtime"
    "sync"
)

var (
    counter int
    wg sync.WaitGroup
    mutex sync.Mutex
)

func main() {
    wg.Add(3)

    go incCounter(1)
    go incCounter(2)
    go incCounter(3)

    wg.Wait()
    fmt.Printf("Final Counter: %d\n", counter)
}

func incCounter(id int) {
    defer wg.Done()

    for count := 0; count < 2; count++ {
        mutex.Lock()
        {
            value := counter
            runtime.Gosched()
            value++
            counter = value
        }
        mutex.Unlock()
    }
}

运行结果：

Final Counter: 6

如上面的代码，最终的结果还是6.

mutex.lock he mutex.Unlock之间的代码，同一时刻只允许一个goroutine进入，所以保证数据的正确性。

补充对于 runtime.Gosched()的理解，有两个问题 1. 当执行了这句话，貌似让出了执行，那么它后面的语句还能执行么

到此这篇关于go语言协程的文章就介绍到这了。希望对大家的学习有所帮助，也希望大家多多支持我们。