go语言中的协程详解

作者:奋斗的大橙子 时间:2024-03-13 00:42:24 

协程的特点

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

2.发生了IO,导致执行阻塞(使用channel让协程阻塞)

与线程本质的不同

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

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

例如:

C# 中创建两个线程

go语言中的协程详解

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

go语言中的协程详解

Go语言中用协程实现一下

runtime.GOMAXPROCS(1)

go语言中的协程详解

go语言中的协程详解

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

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

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

go语言中的协程详解

  • 2.通过channel进行阻塞

go语言中的协程详解

执行的结果一样

go语言中的协程详解

后面又继续执行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?

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

(3)WaitGroup 是什么意思?

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

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

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

go语言中的协程详解

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

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

go语言中的协程详解

补充: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. 当执行了这句话,貌似让出了执行,那么它后面的语句还能执行么

来源:https://www.cnblogs.com/dcz2015/p/10375333.html

标签:go,Golang,协程
0
投稿

猜你喜欢

  • 浅议Wap网页设计中的锚点链接

    2010-12-17 12:41:00
  • 如何利用Pandas删除某列指定值所在的行

    2023-10-29 11:49:39
  • flask session组件的使用示例

    2022-03-17 08:13:07
  • 人性化网页设计技巧

    2007-10-15 13:02:00
  • python数据结构的排序算法

    2021-03-11 04:04:10
  • 如何创建支持FILESTREAM的数据库示例探讨

    2024-01-26 15:30:13
  • 浅析go中的map数据结构字典

    2024-05-22 10:13:05
  • 使用k8s部署Django项目的方法步骤

    2022-12-30 01:59:56
  • js+ajax实现获取文件大小的方法

    2023-08-12 00:22:07
  • 关于Numpy中的行向量和列向量详解

    2021-06-29 20:30:48
  • win10 64bit下python NLTK安装教程

    2023-04-05 19:49:40
  • python-docx文件定位读取过程(尝试替换)

    2022-03-05 14:41:19
  • Python的迭代器和生成器

    2022-04-29 17:56:09
  • python通过apply使用元祖和列表调用函数实例

    2021-02-18 03:18:32
  • sqlserver中重复数据值只取一条的sql语句

    2012-06-06 19:46:31
  • Python函数关键字参数及用法详解

    2023-08-13 00:34:06
  • Go语言defer语句的三种机制整理

    2024-05-02 16:25:25
  • PHP函数原理理解详谈

    2023-06-04 01:56:59
  • Navicat for MySQL 与 MySQL-Front比较

    2009-02-12 17:33:00
  • 你知道哪几种MYSQL的连接查询

    2024-01-20 15:00:34
  • asp之家 网络编程 m.aspxhome.com