【Golang】关于Go语言中如何控制goroutine的数量

在Go语言中，goroutine的创建成本很低，调度效率高，Go语言在设计时就是按以数万个goroutine为规范进行设计的，数十万个并不意外，但是goroutine在内存占用方面确实具有有限的成本，你不能创造无限数量的它们，比如这个例子：

ch := generate() 
go func() { 
        for range ch { } 
}()

这段代码通过generate()方法获得一个channel，然后启动一个goroutine一直去处理这个channel的数据，这个goroutine什么时候会退出？答案是不确定，ch是由函数generate()来决定的，所以有可能这个goroutine永远都不会退出，这就有可能会引发内存泄漏。

goroutine就是G-P-M调度模型中的G，我们可以把goroutine看成是一种协程，创建goroutine也是有开销的，但是开销很小，初始只需要2-4k的栈空间，当goroutine数量越来越大时，同时存在的goroutine也越来越多时，程序就隐藏内存泄漏的问题。看一个例子：

func main()  {
	for i := 0; i < math.MaxInt64; i++ {
		go func(i int) {
			time.Sleep(5 * time.Second)
		}(i)
	}
}

如果不加以控制的话，直接崩溃

1、Context包

Go 语言中的每一个请求的都是通过一个单独的 goroutine 进行处理的，HTTP/RPC 请求的处理器往往都会启动新的Goroutine 访问数据库和 RPC 服务，我们可能会创建多个goroutine 来处理一次请求，而 Context 的主要作用就是在不同的 goroutine 之间同步请求特定的数据、取消信号以及处理请求的截止日期。

Context包主要衍生了四个函数：

func WithCancel(parent Context) (ctx Context, cancel CancelFunc)
func WithDeadline(parent Context, deadline time.Time) (Context, CancelFunc)
func WithTimeout(parent Context, timeout time.Duration) (Context, CancelFunc)
func WithValue(parent Context, key, val interface{}) Context

使用这四个函数我们对goroutine进行控制，具体展开就不再本文说了，我们以WithCancel方法写一个例子：

package main

import (
	"context"
	"fmt"
	"time"
)

func main() {
	ctx, cancel := context.WithCancel(context.Background())
	go Speak(ctx)
	time.Sleep(10 * time.Second)
	cancel()
	time.Sleep(2 * time.Second)
	fmt.Println("拜拜!")
}

func Speak(ctx context.Context) {
	for range time.Tick(time.Second) {
		select {
		case <-ctx.Done():
			fmt.Println("拜拜！")
			return
		default:
			fmt.Println("开始执行")
		}
	}
}

运行结果：

PS D:\cpz\go-demo\test13> go run test4.go
开始执行
开始执行
开始执行
开始执行
开始执行
开始执行
开始执行
开始执行
开始执行
拜拜！
拜拜!

这里我们使用withCancel创建了一个基于Background的ctx，然后启动了一个goroutine每隔1s执行一次，10s后在主goroutine中发送取消新信号，那么启动的goroutine在检测到信号后就会取消退出。

2、channel

我们知道channel是用于goroutine的数据通信，在Go中通过goroutine+channel的方式，可以简单、高效地解决并发问题。上面我们介绍了使用context来达到对goroutine的控制，实际上context的内部实现也是使用的channel，所以有时候为了实现方便，我们可以直接通过channel+select或者channel+close的方式来控制goroutine的退出，我们分别来一写一个例子：

方式1：channel+select

package main

import "fmt"

func fibonacci(ch chan int, done chan struct{}) {
	x, y := 0, 1
	for {
		select {
		case ch <- x:
			x, y = y, x+y
		case <-done:
			fmt.Println("over")
			return
		}
	}
}
func main() {
	ch := make(chan int)
	done := make(chan struct{})
	go func() {
		for i := 0; i < 10; i++ {
			fmt.Println(<-ch)
		}
		done <- struct{}{}
	}()
	fibonacci(ch, done)
}

上面的例子是计算斐波那契数列的结果，我们使用两个channel，一个channel用来传输数据，另外一个channel用来做结束信号，这里我们使用的是select的阻塞式的收发操作，直到有一个channel发生状态改变，我们也可以在select中使用default语句，那么select语句在执行时会遇到这两种情况：

  • 当存在可以收发的Channel时，直接处理该Channel 对应的 case；
  • 当不存在可以收发的Channel 时，执行 default 中的语句；

建议大家使用带default的方式，因为在一个nil channel上的操作会一直被阻塞，如果没有default case,只有nil channel的select会一直被阻塞。

方式2：channel+close

package main

import (
	"fmt"
	"time"
)

func main() {
	ch := make(chan int, 10)
	go func() {
		for i := 0; i < 10; i++ {
			ch <- i
		}
		close(ch)
	}()
	go func() {
		for val := range ch {
			fmt.Println(val)
		}
		fmt.Println("receive data over")
	}()
	time.Sleep(5 * time.Second)
	fmt.Println("program over")
}

channel可以单个出队，也可以循环出队，因为我们可以使用for-range循环处理channel，range ch会一直迭代到channel被关闭，根据这个特性，我们也可做到对goroutine的控制：

我们可以通过以下方式达到控制goroutine数量的目的，不过本身Go的goroutine就已经很轻量了，所以控制goroutine的数量还是要根据具体场景分析，并不是所有场景都需要控制goroutine的数量的，一般在并发场景我们会考虑控制goroutine的数量，接下来我们来看一看如下几种方式达到控制goroutine数量的目的。

0、常用的三方库

写 go 并发程序的时候如果程序会启动大量的goroutine ，势必会消耗大量的系统资源（内存，CPU），所以可以考虑使用goroutine池达到复用goroutine，节省资源，提升性能。也有一些开源的协程池库，例如：ants、go-playground/pool、jeffail/tunny等，这里我们看ants的一个官方例子：

package main

import (
	"fmt"
	ants "github.com/panjf2000/ants/v2"
	"sync"
	"sync/atomic"
	"time"
)

var sum int32

func myFunc(i interface{}) {
	n := i.(int32)
	atomic.AddInt32(&sum, n)
	fmt.Printf("run with %d\n", n)
}

func demoFunc() {
	time.Sleep(10 * time.Millisecond)
	fmt.Println("Hello World!")
}

func main() {
	defer ants.Release()

	runTimes := 1000

	// Use the common pool.
	var wg sync.WaitGroup
	syncCalculateSum := func() {
		demoFunc()
		wg.Done()
	}
	for i := 0; i < runTimes; i++ {
		wg.Add(1)
		_ = ants.Submit(syncCalculateSum)
	}
	wg.Wait()
	fmt.Printf("running goroutines: %d\n", ants.Running())
	fmt.Printf("finish all tasks.\n")

	// Use the pool with a function,
	// set 10 to the capacity of goroutine pool and 1 second for expired duration.
	p, _ := ants.NewPoolWithFunc(10, func(i interface{}) {
		myFunc(i)
		wg.Done()
	})
	defer p.Release()
	// Submit tasks one by one.
	for i := 0; i < runTimes; i++ {
		wg.Add(1)
		_ = p.Invoke(int32(i))
	}
	wg.Wait()
	fmt.Printf("running goroutines: %d\n", p.Running())
	fmt.Printf("finish all tasks, result is %d\n", sum)
}

这个例子其实就是计算大量整数和的程序，这里通过ants.NewPoolWithFunc()创建了一个 goroutine 池。第一个参数是池容量，即池中最多有 10 个goroutine。第二个参数为每次执行任务的函数。当我们调用p.Invoke(data)的时候，ants池会在其管理的 goroutine 中找出一个空闲的，让它执行函数taskFunc，并将data作为参数。

Go语言的官方扩展包为我们提供了一个基于权重的信号量Semaphore，我可以根据信号量来控制一定数量的 goroutine 并发工作，官方也给提供了一个例子：workerPool，代码有点长就不在这里贴了，我们来自己写一个稍微简单点的例子：

package main

import (
	"context"
	"fmt"
	"golang.org/x/sync/semaphore"
	"runtime"
	"sync"
	"time"
)

const (
	// 同时运行的goroutine上限
	Limit = 5
	// 信号量的权重
	Weight = 1
)

func main() {
	start := time.Now()
	names := []int{
		1, 2, 3, 4, 5,
	}

	for i := 1; i <= 100000; i++ {
		names = append(names, i)
	}

	sem := semaphore.NewWeighted(Limit)
	var w sync.WaitGroup
	for _, name := range names {
		w.Add(1)
		go func(name int) {
			sem.Acquire(context.Background(), Weight)
			// ... 具体的业务逻辑

			fmt.Printf("Items is %v, This NumGoroutine is %v\n", name, runtime.NumGoroutine())
			sem.Release(Weight)
			w.Done()
		}(name)
	}
	w.Wait()
	times := time.Since(start)
	fmt.Println(times)
}

上面的例子我们使用 NewWeighted() 函数创建一个并发访问的最大资源数，也就是同时运行的goroutine上限为3，使用Acquire函数来获取指定个数的资源，如果当前没有空闲资源可用，则当前goroutine将陷入休眠状态，最后使用release函数释放已使用资源数量（计数器）进行更新减少，并通知其它 waiters。

主要实现原理是利用waitGroup做并发控制，利用channel可以在goroutine之间进行数据通信，通过限制channel的队列长度来控制同时运行的goroutine数量，例子如下：

package main

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

var (
	// channel长度
	poolCount = 5
	// 复用的goroutine数量
	goroutineCount = 10
)

func main() {
	start := time.Now()
	jobsChan := make(chan int, poolCount)

	// workers
	var wg sync.WaitGroup
	for i := 0; i < goroutineCount; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			for item := range jobsChan {
				fmt.Printf("Items is %v, This NumGoroutine is %v\n", item, runtime.NumGoroutine())
			}
		}()
	}

	// senders
	for i := 0; i < 100000; i++ {
		jobsChan <- i
	}

	// 关闭channel，上游的goroutine在读完channel的内容，就会通过wg的done退出
	close(jobsChan)
	wg.Wait()

	times := time.Since(start)
	fmt.Println(times)
}

这种实现方式真的妙，与信号量的实现方式基本相似，某些场景大家也可以考虑使用这种方式来达到控制goroutine的目的，不过最好封装一下，要不有点丑陋，感兴趣的可以参考：https://github.com/eddycjy/gsema/blob/master/sema.go

本文主要目的是介绍控制goroutine的几种方式、控制goroutine数量的几种方式，goroutine的创建成本低、效率高带来了很大优势，同时也会有一些弊端，这就需要我们在实际开发中根据具体场景选择正确的方式使用goroutine

 

 

posted @ 2022-10-04 00:10  踏雪无痕SS  阅读(862)  评论(0)  编辑  收藏  举报