Go - Goroutine

最新推荐文章于 2022-03-08 09:37:16 发布
最新推荐文章于 2022-03-08 09:37:16 发布
阅读量362 收藏
点赞数
分类专栏： Go
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33961117/article/details/105191757
版权

一、Goroutine

多个线程可以属于同一个进程并共享内存空间。因为多线程不需要创建新的虚拟内存空间，所以它们也不需要内存管理单元处理上下文的切换，线程之间的通信也正是基于共享的内存进行的，与重量级的进程相比，线程显得比较轻量。

虽然线程比较轻量，但是在调度时也有比较大的额外开销。每个线程会都占用 1 兆以上的内存空间，在对线程进行切换时不止会消耗较多的内存，恢复寄存器中的内容还需要向操作系统申请或者销毁对应的资源，每一次线程上下文的切换都需要消耗 ~1us 左右的时间，但是 Go 调度器对 Goroutine 的上下文切换约为 ~0.2us，减少了 80% 的额外开销。

Go 语言的调度器通过使用与 CPU 数量相等的线程减少线程频繁切换的内存开销，同时在每一个线程上执行额外开销更低的 Goroutine 来降低操作系统和硬件的负载。

1-1 开启 Goroutine

go func_name(x, y, z)

package main

import (
	"fmt"
	"time"
)

func say(s string) {
	for i := 0; i < 5; i++ {
		time.Sleep(100 * time.Millisecond)
		fmt.Println(s)
	}
}

func main() {
	go say("world")
	say("hello")
}

二、进程不会等待所有的 Goroutines 执行结束

go 内使用 goroutines 所谓的轻量线程，实现并发。并且在同一个程序中，所有的 goroutines 共享同一个地址空间。

但是由于 goroutines 的效率高，所以程序未等到所有的 goroutines 完成就会结束。

package main
import (  
    "fmt"
    "time"
)
func main() {  
    workerCount := 2
    for i := 0; i < workerCount; i++ {
      	// 使用轻量线程 执行函数
        go doit(i)
    }
    time.Sleep(1 * time.Second)
    fmt.Println("all done!")
}
func doit(workerId int) {  
    fmt.Printf("[%v] is running\n",workerId)
    time.Sleep(3 * time.Second)
    fmt.Printf("[%v] is done\n",workerId)
}

/*
[0] is running 
[1] is running 
all done!
*/

一个最常见的解决方法是使用 WaitGroup 变量，sync.WaitGroup 能有效的阻塞代码

package main
import (  
    "fmt"
    "sync"
)
func main() {  
    var wg sync.WaitGroup
    done := make(chan struct{}) // 创建结构体通道
    workerCount := 2
    for i := 0; i < workerCount; i++ {
        wg.Add(1)
        go doit(i,done,wg)
    }
    close(done)
    wg.Wait()
    fmt.Println("all done!")
}
func doit(workerId int,done <-chan struct{},wg sync.WaitGroup) {  
    fmt.Printf("[%v] is running\n",workerId)
  	defer wg.Done() 
		// defer 确保 wg.Done() 在该函数执行完毕之后执行，用于解锁资源
    <- done
    fmt.Printf("[%v] is done\n",workerId)
}

/*
[0] is running 
[0] is done 
[1] is running 
[1] is done
*/

但通常会出现死锁问题。
死锁：两个或两个以上的线程，因抢夺资源而造成相互等待的无解结果。

各个 worker 都得到了原始的 WaitGroup 变量的一个拷贝。所有 worker 都在等着对 wg 内存空间资源的修改权，所以当 worker 执行wg.Done()时，并没有在主 goroutine 上的 WaitGroup 变量上生效。

fatal error: all goroutines are asleep - deadlock!

package main
import (  
    "fmt"
    "sync"
)
func main() {  
    var wg sync.WaitGroup
  	// 注意 已经初始，非nil
    done := make(chan struct{})
    wq := make(chan interface{})
  	// 非缓冲信道，发送方会阻塞直到接收方从信道中接受了值
    workerCount := 2
    for i := 0; i < workerCount; i++ {
        wg.Add(1)
        go doit(i,wq,done,&wg)
    }
    for i := 0; i < workerCount; i++ {
        wq <- i
    }
    close(done) // 关闭信道，禁止数据流入，但可读。
    wg.Wait()
    fmt.Println("all done!")
}
func doit(workerId int, wq <-chan interface{},done <-chan struct{},wg *sync.WaitGroup) {  
    fmt.Printf("[%v] is running\n",workerId)
    defer wg.Done()
    for {
      	// select 是 Go 中的一个控制结构，类似于用于通信的 switch 语句。每个 case 必须是一个通信操作，要么是发送要么是接收。
      	// select 能让 goroutine 同时等待多个 channel 的可读或可写
      	// 当满足多个 case 时，随机执行一个可运行的case 若没有 case 可执行将阻塞等待，直到存在可执行的case
        select {
        case m := <- wq:
            fmt.Printf("[%v] m => %v\n",workerId,m)
        case <- done:
          	/*
          	a,ok:= <- done
          	fmt.Printf("[%v] is done %v,%v\n",workerId,a,ok)
          	[1] is done {},false
          	*/
            // 从一个nil channel中接收数据会一直被block
          	// 从关闭的 channel 中不但可以读取已发送的数据，还可以不断读取初始值
            fmt.Printf("[%v] is done\n",workerId)
            return
        }
    }
}

// 注意：执行结果不唯一
/*
[1] is running
[1] m => 0
[0] is running
[0] is done
[1] m => 1
[1] is done
all done!
*/
/*
[1] is running
[1] m => 0
[0] is running
[0] m => 1
[0] is done {}
[1] is done {}
all done!
*/
// 主线程执行程序，0 1 随机执行case，走到 done 即结束循环，走 wq 即读取
// 主线程同时执行 wq 的写入，并关闭信道，等待所有线程完成

三、for 循环的 goroutine 存在数据错误

for 循环中迭代的变量，都是指向同一个内存地址，即 for 循环中创建的闭包都为引用传递，而由于 goroutine 本身的执行速度，很可能主线程已经循环结束，子线程才开始进行执行，导致数据获取的已经不是想象中的那个值。

package main
import (  
    "fmt"
    "time"
)
func main() {  
    data := []string{"one","two","three"}
    for _,v := range data {
        go func() {
            fmt.Println(v)
        }()
    }
    time.Sleep(3 * time.Second)
}
/*
three
three
three
*/

然而，若主线程中存在io等待拖慢速度，会发现 子线程仍然会获取到想象中的值。

package main
import (
	"fmt"
	"time"
)
func main() {
	data := []string{"one","two","three"}
	for _,v := range data {
		go func() {
			fmt.Println(v)
		}()
		time.Sleep(3 * time.Second)
	}
	time.Sleep(3 * time.Second)
}

/*
one
two
three
*/

解决方式：1、保存每次迭代的值 2、每次迭代的值是匿名 goroutine 的参数

package main
import (  
    "fmt"
    "time"
)
func main() {  
    data := []string{"one","two","three"}
    for _,v := range data {
        vcopy := v // 保存每次迭代的值，值传递，仅仅复制值
        go func() {
            fmt.Println(vcopy)
        }()
    }
    time.Sleep(3 * time.Second)
    //goroutines print: one, two, three
}

ackage main
import (  
    "fmt"
    "time"
)
func main() {  
    data := []string{"one","two","three"}
    for _,v := range data {
        go func(in string) {
            fmt.Println(in)
        }(v) // 作为参数传入执行
    }
    time.Sleep(3 * time.Second)
    //goroutines print: one, two, three
}

注意：若循环的对象是指针，则每次取的地址都不同，则不存在指向错误。

package main

import (
   "fmt"
   "time"
)

type field struct {
   name string
}

func (p *field) print() {
   fmt.Println(p.name)
}
func main() {
   data := []*field{{"one"}, {"two"}, {"three"}}
   for _, v := range data {
      fmt.Printf("----->%v\n", v)
      go v.print()
   }
   time.Sleep(3 * time.Second)
}

/*
----->&{one}
----->&{two}
----->&{three}
three
two
one
*/

四、Goroutine 阻塞导致的资源泄露

func First(query string, replicas ...Search) Result {  
    c := make(chan Result)
    searchReplica := func(i int) { c <- replicas[i](query) }
    for i := range replicas {
        go searchReplica(i)
    }
    return <-c
}

改函数每次循环都会起一个 goroutine，每一个 goroutine 会将结果发送到 channel中。

但由于没有缓存，则只有第一个 goroutine 放入了数据并释放资源，其他的 goroutine 在写入数据前，就已经被中断，导致阻塞。

func First(query string, replicas ...Search) Result { 
  	// 使用相同容量大小的缓存信道，可以有效防止线程阻塞
    c := make(chan Result,len(replicas))
    searchReplica := func(i int) { c <- replicas[i](query) }
    for i := range replicas {
        go searchReplica(i)
    }
    return <-c
}

func First(query string, replicas ...Search) Result {  
    c := make(chan Result,1)
    searchReplica := func(i int) { 
      	// 存在 default 的select 保证了当前 channel 无法收到消息的情况下，也不会阻塞	
        select {
        case c <- replicas[i](query):
        default:
        }
    }
    for i := range replicas {
        go searchReplica(i)
    }
    return <-c
}

func First(query string, replicas ...Search) Result {  
    c := make(chan Result)
  	// 使用特殊的取消的 channel 终止 workers，worker 无法放入数据
    done := make(chan struct{})
    defer close(done)
    searchReplica := func(i int) { 
        select {
        case c <- replicas[i](query):
        case <- done:
        }
    }
    for i := range replicas {
        go searchReplica(i)
    }
    return <-c
}

五、在使用 goroutine 的基础上提高并发、并行量

Go 1.4 及以下版本值使用一个执行上下文、OS线程，这意味着只有一个 goroutine 能在任何时间执行。从1.5版本开始，可以使用 runtime.NumCPU() 用于设置CPU的启动数量，这个数量可以设置到超过实际上系统的CPU数量。你可以使用 GOMAXPROCS 这个环境变量，通过 runtime.GOMAXPROCS() 调整CPU的值

GOMAXPROCS 代表CPU的数量，可以使用该数量来允许 goroutine。且该值的数量可以设置到大于CPU的数量，最大值为 256。

package main
import (  
    "fmt"
    "runtime"
)
func main() {  
    fmt.Println(runtime.GOMAXPROCS(-1)) //prints: 1
    fmt.Println(runtime.NumCPU())       //prints: 1 (on play.golang.org)
    runtime.GOMAXPROCS(20)
    fmt.Println(runtime.GOMAXPROCS(-1)) //prints: 20
    runtime.GOMAXPROCS(300)
    fmt.Println(runtime.GOMAXPROCS(-1)) //prints: 256
}

六、无法保证多个 goroutine 的执行顺序

go 会对某些操作进行重新排序，可以保证一个 goroutine 内的执行顺序不变，不能保证多个 goroutine 的执行顺序。

package main
import (  
    "runtime"
    "time"
)
var _ = runtime.GOMAXPROCS(3)
var a, b int
func u1() {  
    a = 1
    b = 2
}
func u2() {  
    a = 3
    b = 4
}
func p() {  
    println(a)
    println(b)
}
func main() {  
    go u1()
    go u2()
    go p()
    time.Sleep(1 * time.Second)
}

每次运行，打印的结果都不相同。

注意：如果需要保持执行顺序，需要使用 channel 或使用 sync 包构建合适的结构体

七、goroutine 优先调度冲突

如果存在一个不让调度器运行的 for 循环时，就会发生 一个goroutine 阻止其他 goroutine 运行的情况

package main
import "fmt"
func main() {  
    done := false
    go func(){
        done = true
    }()
    for !done {
      // 包含不会触发调度器执行的代码，就会导致阻止问题
    }
    fmt.Println("done!")
}

调度器会在 GC、go 声明、阻塞 channel操作、阻塞系统调用、lock操作、非内联函数调用之后运行

package main
import "fmt"
func main() {  
    done := false
    go func(){
        done = true
    }()
    for !done {
        fmt.Println("not done!") //not inlined
    }
    fmt.Println("done!")
}

// 查看是否为内联函数
go build -gcflags -m

可以使用 runtime.Goshed() 显示唤起调度器

package main
import (  
    "fmt"
    "runtime"
)
func main() {  
    done := false
    go func(){
        done = true
    }()
    for !done {
        runtime.Gosched()
    }
    fmt.Println("done!")
}

参考阅读

Go 语言与设计 调度器

LSYHhhhh
关注
专栏目录
go 开了多少个goroutine 怎么看_实战分析一个运行起来会卡死的Go程序
weixin_29955689的博客
12-27 1361
序言最近一位非常热心的网友建议结合demo来分析一下goroutine的调度器，而且还提供了一个demo代码，于是便有了本文，在此对这位网友表示衷心的感谢！这位网友提供的demo程序可能有的gopher以前见过，已经知道了具体原因，但本文假定我们是第一次遇到这种问题，然后从零开始，通过一步一步的分析和定位，最终找到问题的根源及解决方案。虽然本文不需要太多的背景知识，但最好使用过gdb或delve调...
上周并发题的解题思路以及介绍Go语言调度器
kevin_tech的博客，微信搜「网管叨bi叨」
06-03 235
上周的文章《Go并发编程里的数据竞争以及解决之道》最后留下了一个用并发解决的思考题，期间有几位同学留言说了自己的实现思路，也有两位直接私信发代码让我看的，非常感谢几位的积极参与。今天的文...
并发 - Go 语言学习笔记
weixin_33882443的博客
06-18 173
概述 并发 (concurrency) 是指同时管理很多事情，这些事情可能只做了一半就被暂停去做别的事情了。 Go 语言里的并发指的是能让某个函数独立于其它函数运行的能力。当一个函数创建为 goroutine 时，Go 会将其视为一个独立的工作单元。这个单元会被调度到可用的逻辑处理器上执行。 Go 语言只需通过 go 关键字来开启 goroutine 即可实现并发。 Goroutine 每一个并发...
Go中的goroutine理解
浴血重生-学习空间
07-01 575
goroutine 机制 Go语言支持goroutine，每个goroutine需要能够独立运行，所以它们必须都有自己的栈。假如每个goroutine分配固定栈大小并且不能增长，太小则会导致溢出，太大又会浪费空间，无法存在许多的goroutine。为了解决这个问题，goroutine可以初始时只给栈分配很小的空间，然后随着使用过程中的需要自动地增长。这就是为什么Go可以开千千万万个gorouti...
Go 并发常用知识点实例
Mr.Buffoon
12-24 570
Go中天然的支持并发，Go允许使用go语句开启一个新的运行期线程，即 goroutine，以一个不同的、新创建的goroutine来执行一个函数。同一个程序中的所有goroutine共享同一个地址空间。 Goroutine非常轻量，除了为之分配的栈空间，其所占用的内存空间微乎其微。并且其栈空间在开始时非常小，之后随着堆存储空间的按需分配或释放而变化。内部实现上，goroutine会在多个操作系统线...
go-goroutine
yh_android的专栏
10-13 862
goroutine goroutine是Go并行设计的核心。goroutine说到底其实就是线程，但是它比线程更小，十几个goroutine可能体现在底层就是五六个线程，Go语言内部帮你实现了这些goroutine之间的内存共享。执行goroutine只需极少的栈内存(大概是4~5KB)，当然会根据相应的数据伸缩。也正因为如此，可同时运行成千上万个并发任务。goroutine比thread更易用、...
Go goroutine
阿信今天的代码没bug的博客
07-06 97
使用sync.WaitGroup和go 组合，实现多线程 可增长的栈 OS线程一般都有固定的栈内存（通常为2MB），一个gorutine的栈在其生命周期开始时只有很小的栈（典型情况下2KB），goroutine的栈不是固定的，它可以按需增大和缩小，goroutine的栈大小限制可以达到1GB，虽然极少会用到这么大。所以在Go语言中，一次创建十万左右的goroutine也是可以的。 goroutine调度 GMP是Go语言运行时（runtime）层面的实现，是go语言自己实现的一套调度系统。区...
go goroutine
咳咳，请多指教
03-08 149
Go语言中使用 goroutine 非常简单，只需要在函数或方法调用前加上go关键字就可以创建一个 goroutine ，从而让该函数或方法在新创建的 goroutine 中执行 创建一个新的 goroutine 运行函数f 或 匿名函数 go f() 或 go func(){ // ... }() package main import "fmt" func main() { //开启一个主的 Goroutine 执行 main go hello() //开启一个主的 Gorout.
Go基础--goroutine和channel
06-19
总结起来，Go 语言中的 goroutine 和 channels 提供了一种强大而优雅的方式来处理并发和通信。它们使程序员能够轻松地构建并发系统，而无需深入底层线程管理和同步原语。通过理解和熟练运用这些概念，你可以构建出高...
都说 Go 可以开启成千上万的 Goroutine，那调度器是怎么处理核上任务分配的？
笔记
08-27 580
转载地址：https://mp.weixin.qq.com/s/_By9rjPgb8zqIpVrsJrToQ Illustration created for “A Journey With Go”, made from the original Go Gopher, created by Renee French. ℹ️这篇文章基于 Go 1.13 版本。 在 Go 中创建 gorotine 既方便又快捷，然而 Go 在同一时间内最多在一个核上运行一个 gorotine，因此需要一种方法来.
Go并发模式/设计模式-重启异常的goroutine
u013862108的博客
05-04 679
在长期运行的后台程序中， 如果没有外部干涉，一个goroutine 很容易进入一个不正常的状态，并且无法恢复。 在一个长期运行的程序中，建立一个机制来 监控 goroutine 是否 是健康的的状态 是有用的， 当它们变得异常时， 就可以重启。我们将这个重启goroutine 的过程称为 "治愈 Healing" 为了治愈goroutine, 需要使用心跳模式来检查我们正在监控的gorouti...
Go 语言编程 — 并发 — Goroutine 协程
烟云的计算
07-06 1835
目录 文章目录目录goroutinechannel通道缓冲区遍历通道与关闭通道 goroutine Golang 原生支持并发，体现在 Golang 提供了 go 关键字。 格式： go 函数名(形参列表) go 语句会直接开启一个新的运行期线程，即：goroutine。以一个不同的、新创建的 goroutine 来执行一个函数。goroutine 的本质是一个轻量级线程，goroutine 的调度由 Golang 运行时进行管理， 同一个程序中的所有 goroutine 共享同一个地址空间。 packa
Go语言并发之道学习十三 治愈异常的goroutine
daily886的博客
08-28 403
治愈异常的goroutine package main import ( "log" "time" "os" ) /* 治愈异常的goroutine： 在长期运行的后台程序中，经常会有一些长时间运行的goroutine。 这些goroutine 经常处于阻塞状态，等待数据以某种方式到达，然后唤醒它们，进行一些处理，再返回一些数据。 如果没有外部干预，一个goroutine 很容易进入...
go代码-goroutine
07-16
Go语言，也被称为Golang，是由Google开发的一种静态类型的、编译型的、并发型的、垃圾回收的、具有C风格语法的编程语言。在Go语言中，goroutine是其核心特性之一，它是一种轻量级的线程，用于实现高效的并发处理。...
Go-goroutines
A Flying Bird
09-01 1828
Go-goroutines
Go语言学习笔记-并发
alstonyaoyi的博客
07-10 103
Go 语言支持并发，我们只需要通过 go 关键字来开启 goroutine 即可。 goroutine 是轻量级线程，goroutine 的调度是由 Golang 运行时进行管理的。 goroutine 语法格式： go 函数名( 参数列表 ) 例如： go f(x, y, z) 开启一个新的 goroutine: f(x, y, z) Go 允许使用 go 语句开启一个新的运行期线程， 即 goroutine，以一个不同的、新创建的 goroutine 来执行一个函数。 同一个程序中的所有 goro
Go并发（1）
One2zeror的专栏
10-16 931
Go从语言本身支持并发，而不是由某个库或者模块来实现并发，可谓天生丽质。goroutine从根本上与线程不同，goroutine更加轻量化。 　　看下面这个常见的网络模型：package mainimport ( "fmt" "net" )func manageClient(conn net.Conn) { conn.Write([]byte("Hi!")) conn.Close(
Go并发模式之 防止goroutine泄漏
u013862108的博客
03-17 1615
goroutine 有以下几种方式被终止： 1。 当他完成了它的工作。 2。 因为不可恢复的错误， 它不能继续工作 3。 当他被告知 需要终止工作。 我们可以简单的使用前两种方法， 因为这两种方法隐含在你的算法中， 但"取消工作" 又是怎样工作的呢？ 例如：这样情况： 子goroutine 是否该继续执行可能是以许多其他goroutine 状态的认知为基础的。 通常是 main gorou...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值