go语言中的协程详解

更新时间：2022年07月16日 09:05:44 作者：奋斗的大橙子

本文详细讲解了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语言协程的文章就介绍到这了。希望对大家的学习有所帮助，也希望大家多多支持脚本之家。

您可能感兴趣的文章:

Go gRPC服务端流式RPC教程示例
这篇文章主要为大家介绍了Go gRPC服务端流式RPC教程示例，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪
2022-06-06
Golang实现Redis过期时间实例探究
这篇文章主要介绍了Golang实现Redis过期时间实例探究，
2024-01-01
深入理解Go Gin框架中间件的实现原理
在Go Gin框架中,中间件是一种在请求处理过程中插入的功能模块,它可以用于处理请求的前置和后置逻辑,例如认证、日志记录、错误处理等,本文将给大家介绍一下Go Gin框架中间件的实现原理,需要的朋友可以参考下
2023-09-09
Golang使用切片实现单链表的示例代码
单链表（Single Linked List）是链表数据结构的一种实现方式,它包含一系列节点（Node）,每个节点都包含一个数据域和一个指向下一个节点的指针,本文给大家介绍了Golang使用切片实现单链表的操作,需要的朋友可以参考下
2024-05-05
axios gin的GET和POST请求实现示例
这篇文章主要为大家介绍了axios gin的GET和POST请求实现示例，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步早日升职加薪
2022-04-04
Go语言中序列化与反序列化示例详解
我们的数据对象要在网络中传输或保存到文件,就需要对其编码和解码动作,Go语言当然也支持所有这些编码格式,下面这篇文章主要给大家介绍了关于Go语言中序列化与反序列化的相关资料,需要的朋友可以参考下
2022-07-07
go语言中context的使用说明
Go语言中的Context是用于在多个函数或goroutine之间传递取消信号、超时控制、截止时间和请求范围数据的重要概念,它提供了更好的控制和管理,适用于并发编程中需要传递状态或进行资源清理的场景
2024-12-12
go语言中读取配置文件的方法总结
这篇文章主要为大家详细介绍了go语言中读取配置文件的几个常见方法,文中的示例代码讲解详细,具有一定的借鉴价值,需要的小伙伴可以参考下
2023-08-08
如何使用golang实现traceroute
这篇文章主要介绍了如何使用golang实现traceroute,该工具在linux环境下的命令是traceroute或者tracepath，在windows下命令是tracert，本文给大家详细讲解需要的朋友可以参考下
2023-04-04
GoFrame框架数据校验之校验对象校验结构体
这篇文章主要为大家介绍了GoFrame框架数据校验之校验对象校验结构体示例详解，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪
2022-06-06