go-errgroup使用

已于 2022-08-30 14:13:16 修改
阅读量1.4k 收藏 1
点赞数
文章标签： golang 后端
于 2022-07-06 11:36:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Zerore/article/details/125632695
版权

errgroup用于goroutine的同步，g.Go接收func() error函数作为参数，如果有一个goroutine返回error，则调用cancel函数取消context。因此一般接收的函数内部使用闭包，使用外部提供的context。

type Group struct {
	cancel func()    	// 用于取消context
	wg sync.WaitGroup   // 用于线程同步
	sem chan token		// 用于控制并发goroutine数量
	errOnce sync.Once   // 只cancel一次
	err     error		//  记录某个错误
}

// 其主要方法
func WithContext(ctx context.Context) (*Group, context.Context) { ... } // 创建Group
func (g *Group) Go(f func() error) { ... }  // 启动goroutine
func (g *Group) Wait() error       { ... }  // 等待所有线程结束
func (g *Group) SetLimit(n int)    { ... }  // 设置并发数量

Parallel（并发任务同步）

type Result string
type Search func(ctx context.Context, query string) (Result, error)

func myFunc(kind, query string) (Result, error) {
	// 模拟函数调用，web耗时2秒成功，image耗时4秒失败，video耗时6秒成功
	if kind == "web" {
		fmt.Println("web start")
		time.Sleep(2  * time.Second)
		fmt.Println("web end")
		return Result(fmt.Sprintf("%s result for %q", kind, query)), nil
	} else if kind == "image" {
		fmt.Println("image start")
		time.Sleep(4  * time.Second)
		fmt.Println("image end")
		return "", errors.New("image failed")
	} else {
		fmt.Println("video start")
		time.Sleep(6 * time.Second)
		fmt.Println("video end")
		return Result(fmt.Sprintf("%s result for %q", kind, query)), nil
	}
}
func fakeSearch(kind string) Search {
	return func(ctx context.Context, query string) (Result, error){
		done := make(chan Result, 1) // buf chan, 防止ctx直接返回时goroutine阻塞， 用来传递返回的Result
		errch := make(chan error, 1) // buf chan, 防止ctx直接返回时goroutine阻塞， 用来传递返回的err
		go func() {
			// 添加一个验证是否goroutine泄露的打印，如果有，说明每个goroutine都执行完了，不存在泄露
			defer func() {
				fmt.Printf("%s back goroutine end\n", kind)
			}()
			resp, err := myFunc(kind, query)
			if err != nil {
				errch <- err
				close(done)
			} else {
				done <- resp
			}
		}()
		select {
		case <- ctx.Done(): // 如果这里返回，会造成goroutine泄露，该怎么办？chan buf设置为1
			fmt.Printf("%s ctx.Done\n", kind)  // 由于image返回报错，导致kind为video时不等后台myFunc执行完就直接走到这里，
			return "", ctx.Err()
		case rsp, ok := <- done: // 使用done是否关闭来区分返回成功和失败
			if !ok {
				err := <- errch
				return "", err
			} else {
				return rsp, nil
			}
		}

	}
}

var (
	Web = fakeSearch("web")
	Image = fakeSearch("image")
	Video = fakeSearch("video")
)

func main() {
	Google := func(ctx context.Context, query string) ([]Result, error) {
		g, ctx := errgroup.WithContext(ctx)

		searches := []Search{Web, Image, Video}
		results := make([]Result, len(searches))

		for i, search := range searches {
			i, search := i, search
			// g.Go只接收无参函数，此无参函数内部，大部分变量都是函数外的变量，因此形成闭包
			g.Go(func() error {
				// search:     是外部变量，且由于延迟绑定，前一步必须重新赋值给search；
				// ctx, query: 是外部变量，但是不会变化，所以使用安全？
				result, err := search(ctx, query)
				if err == nil {
					results[i] = result // 给外面的results赋值？这里不会造成data race吗(存在data race)？
				}
				return err
			})
		}
		if err := g.Wait(); err != nil {
			return nil, err
		}
		return results, nil
	}


	results, err := Google(context.Background(), "golang")
	if err != nil {
		fmt.Printf("Google err: %v\n", err)

		time.Sleep(5 * time.Second)
		return
	}

	time.Sleep(5 * time.Second)
	// 都成功，打印所有结果
	for _, result := range results {
		fmt.Println(result)
	}

}

上面程序用了两个chan，下面用一个chan实现：

type Result string
type Search func(ctx context.Context, query string) (Result, error)

type response struct {
	resp Result
	err error
}
// myFunc 模拟真实函数调用，web耗时2秒成功，image耗时4秒失败，video耗时6秒成功
func myFunc(kind, query string) (Result, error) {
	// 模拟函数调用，web耗时2秒成功，image耗时4秒失败，video耗时6秒成功
	if kind == "web" {
		fmt.Println("web start")
		time.Sleep(2  * time.Second)
		fmt.Println("web end")
		return Result(fmt.Sprintf("%s result for %q", kind, query)), nil
	} else if kind == "image" {
		fmt.Println("image start")
		time.Sleep(4  * time.Second)
		fmt.Println("image end")
		return "", errors.New("image failed")
	} else {
		fmt.Println("video start")
		time.Sleep(6 * time.Second)
		fmt.Println("video end")
		return Result(fmt.Sprintf("%s result for %q", kind, query)), nil
	}
}

func fakeSearch(kind string) Search {
	return func(ctx context.Context, query string) (Result, error){
		done := make(chan response, 1) // 为避免goroutine泄露

		// 后台线程负责调用函数，往done中写数据
		go func() {
			resp, err := myFunc(kind, query)  // 真正的耗时操作，这里有个问题：就是ctx取消时，这个耗时操作仍在继续，无法取消
			done <- response{resp, err}
		}()

		// 主线程监听done和ctx
		select {
		case <- ctx.Done(): // 如果这里返回，是否会造成goroutine泄露？
			return "", ctx.Err()
		case r := <- done:
			return r.resp, r.err
		}
	}
}

var (
	Web = fakeSearch("web")
	Image = fakeSearch("image")
	Video = fakeSearch("video")
)
func main() {
	Google := func(ctx context.Context, query string) ([]Result, error) {
		g, ctx := errgroup.WithContext(ctx)

		searches := []Search{Web, Image, Video}    // 构造三个函数
		results := make([]Result, len(searches))   // 三个函数的结果

		for i, search := range searches {
			i, search := i, search

			g.Go(func() error {
				// search:     是外部变量，且由于延迟绑定，前一步必须重新赋值给search；
				// ctx, query: 是外部变量，但是不会变化，所以使用安全？
				result, err := search(ctx, query)
				if err == nil {
					results[i] = result // 给外面的results赋值？这里不会造成data race吗(确实存在data race)？
				}
				return err
			})
		}

		if err := g.Wait(); err != nil {
			return nil, err
		}
		return results, nil
	}


	results, err := Google(context.Background(), "golang")
	if err != nil {
		fmt.Printf("Google err: %v\n", err)

		time.Sleep(5 * time.Second)
		return
	}

	time.Sleep(5 * time.Second)
	// 都成功，打印所有结果
	for _, result := range results {
		fmt.Println(result)
	}

}

pipeline（管道模式处理）

package main

import (
	"context"
	"crypto/md5"
	"fmt"
	"io/ioutil"
	"log"
	"os"
	"path/filepath"

	"golang.org/x/sync/errgroup"
)

type result struct {
	path string
	sum  [md5.Size]byte
}

// MD5All pipeline模式，一些goroutine往里写，另外一些goroutine往外读

// MD5All 读取以root为根节点的文件树结构，返回文件路径和md5值对应的map。
// 如果目录遍历失败或者任何读操作失败，函数返回一个错误。
// MD5All reads all the files in the file tree rooted at root and returns a map
// from file path to the MD5 sum of the file's contents. If the directory walk
// fails or any read operation fails, MD5All returns an error.
func MD5All(ctx context.Context, root string) (map[string][md5.Size]byte, error) {
	// 当g.Wait()返回时ctx被取消
	// 当MD5All返回，甚至是错误返回时，所有的goroutine都已经结束，他们所用的内存将被垃圾回收
	// ctx is canceled when g.Wait() returns. When this version of MD5All returns
	// - even in case of error! - we know that all of the goroutines have finished
	// and the memory they were using can be garbage-collected.
	g, ctx := errgroup.WithContext(ctx)
	paths := make(chan string) // 这里采用unbuffer模式，是否会泄露？（下面超时时发送方直接close，因此接收方不会阻塞）

	// 这里只开一个线程用于walk，将获取到的path放入到paths 这个chan中
	g.Go(func() error {
		defer close(paths) // 引用外部的paths  由发送者进行close

		return filepath.Walk(root, func(path string, info os.FileInfo, err error) error {
			if err != nil {
				return err
			}
			if !info.Mode().IsRegular() {
				return nil
			}

			select {
			case paths <- path:
			case <-ctx.Done(): // 引用外部的ctx
				return ctx.Err()
			}
			return nil
		})
	})

	// Start a fixed number of goroutines to read and digest files.
	c := make(chan result) // 这里也是unbuffer，是否会泄露
	const numDigesters = 20
	// 计算md5比较耗时，开20个goroutine同时计算
	for i := 0; i < numDigesters; i++ {
		g.Go(func() error {
			for path := range paths { // 引用外部paths， 外部的paths何时关闭（walk执行完或执行失败或超时）？
				data, err := ioutil.ReadFile(path)
				if err != nil {
					return err
				}
				select {
				case c <- result{path, md5.Sum(data)}:
				case <-ctx.Done(): // 引用外部的ctx
					return ctx.Err()
				}
			}
			return nil
		})
	}

	// 等待所有goroutine结束
	go func() {
		g.Wait()
		close(c) // 这里关闭后，main goroutine才不会阻塞
	}()

	m := make(map[string][md5.Size]byte)

	for r := range c { // c何时close？等所有的goroutine都结束
		m[r.path] = r.sum
	}

	// 检查是否有goroutine失败。
	// 因为g累积了错误，我们不需要在单独的结果集中发送或检查它们。
	// 这里意思是g的错误只记录一个，不需要再通过chan发送错误了
	// Check whether any of the goroutines failed. Since g is accumulating the
	// errors, we don't need to send them (or check for them) in the individual
	// results sent on the channel.

	if err := g.Wait(); err != nil {
		return nil, err
	}
	return m, nil
}

func MyMD5All(ctx context.Context, root string) (map[string][md5.Size]byte, error) {
	// 传入一个ctx和root节点，获取遍历文件的md5
	path_chan := make(chan string) // buffered or unbuffered, 待定
	g, ctx := errgroup.WithContext(ctx)

	// g.Go中函数一旦返回error，触发g.cancel，取消ctx
	g.Go(func() error {
		defer close(path_chan)

		return filepath.Walk(root, func(path string, info os.FileInfo, err error) error {
			if err != nil {
				return err
			}
			if !info.Mode().IsRegular() {
				return nil
			}

			select {
			case path_chan <- path:
			case <-ctx.Done():
				return ctx.Err()
			}
			return nil
		})
	})

	result_chan := make(chan result) // buffered or unbuffered, 待定

	for i := 0; i < 10; i++ {
		g.Go(func() error {
			// close时退出for循环
			for path := range path_chan {
				data, err := ioutil.ReadFile(path)
				if err != nil {
					return err
				}

				select {
				case result_chan <- result{path, md5.Sum(data)}:
				case <-ctx.Done():
					return ctx.Err()
				}
			}
			return nil
		})
	}

	//
	go func() {
		g.Wait()
		close(result_chan)
	}()

	m := make(map[string][md5.Size]byte)
	for r := range result_chan {
		m[r.path] = r.sum
	}

	// Wait依托于sync.WaitGroup的Wait和context.Cancel，都是可以重复调用的
	if err := g.Wait(); err != nil {
		return nil, err
	}
	return m, nil
}

// Pipeline demonstrates the use of a Group to implement a multi-stage
// pipeline: a version of the MD5All function with bounded parallelism from
// https://blog.golang.org/pipelines.
func main() {
	m, err := MD5All(context.Background(), ".")
	if err != nil {
		log.Fatal(err)
	}

	for k, sum := range m {
		fmt.Printf("%s:\t%x\n", k, sum)
	}
}

注意点：

  • 在errgroup使用中，由于func (g *Group) Go(f func() error)接收的是无参数函数，因此内部通过闭包的方式引用外部参数，比如常用的ctx。
  • errgroup中一旦某个g.Go()返回错误，会触发g.err赋值和cancel ctx, 且只会触发一次，这样其他的goroutine会通过监听ctx的方式来结束任务，就达到了一个任务失败，全部任务级联取消的效果。
  • errgroup内部通过名为sem的buffered chan来控制并发的goroutine数。
  • errgroup有个缺点，
Zerore
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
golang-cross:使用CGO的golang交叉编译器
03-31
戈朗克罗斯 Docker容器可对包含cgo支持的go软件包进行交叉编译... 建立跨语言的图像docker build --build-arg GO_VERSION=1.16.2 --build-arg GOLANG_DIST_SHA=542e936b19542e62679766194364f45141fde55169db2d8d01046
go-face:使用Go进行人脸识别
05-01
go-face使用流行的机器学习工具包为Go实现人脸识别。 如果您是概念的新手，请阅读文，了解一些背景细节。 要求 要编译go-face，您需要安装dlib（> = 19.10）和libjpeg开发包。 Ubuntu 18.10 +，Debian SID 最新...
【Golang】使用Golang使用errorgroup
tr6666的博客
04-15 494
在并发编程中，我们经常会遇到这样的场景：启动多个 goroutine 去并发处理任务，如果其中一个出错，其他的都应该被取消。在 Go 语言中，我们可以使用 errgroup 包来简化这种模式的实现。errgroup 提供了一种优雅的方式来处理并发任务中的错误。它允许我们并发执行多个任务，并在任何一个任务失败时取消所有任务。这可以帮助我们编写出更加健壮和易于理解的并发代码。如果你在使用 Go 进行并发编程，我强烈建议你试试 errgroup。
Go语言ErrGroup
YIYIYI
07-14 1889
Go语言ErrGroup
2024年C C++最新Go waitgroup和errgroup学习_go errgroup waitgroup(1)，2024年最新2024年C C++开发学习路线
最新发布
2401_84978667的博客
05-13 288
derived ctx被取消的场景：1. 传递给Go方法的函数第一次返回non-nil 2. Wait第一次返回时non-nil。函数一直被阻塞，直到所有go routine返回，或者第一个non-nil错误返回。返回一个新的group以及一个derived ctx。第一次报错则取消g，错误通过Wait方法返回。启动一个新的go routine执行f函数。
go errgroup 用法示例
papaya的博客
07-23 9704
Go团队在实验仓库中添加了一个名为sync.errgroup的新软件包。 sync.ErrGroup再sync.WaitGroup功能的基础上，增加了错误传递，以及在发生不可恢复的错误时取消整个goroutine集合，或者等待超时 其中包含的函数如下： func WithContext(ctx context.Context) (*Group, context.Context) Go(...
并发编程包之 errgroup
qq_39397165的博客
08-05 658
欢迎大家点击上方文字「Golang梦工厂」关注公众号，设为星标，第一时间接收推送文章。前言哈喽，大家好，我是asong，今天给大家介绍一个并发编程包errgroup，其实这个包就是对syn...
go并发小工具errgroup
柳清风的专栏
12-30 775
先看demo package main import ( "fmt" "golang.org/x/sync/errgroup" "net/http" ) func main() { var g errgroup.Group var urls = []string{ "http://www.golang.org/", "http://www.xxxzzzzzzxxxx.com", "http://www.google.com/", } for i := range urls {
golang errgroup的用法及用处
热门推荐
程序员面试精选【codeoffer】
10-12 1万+
一般在golang 中想要并发运行业务时会直接开goroutine，关键字go ,但是直接go的话函数是无法对返回数据进行处理error的。 解决方案： ## 初级版本： 一般是直接在出错的地方打入log日志,将出的错误记录到日志文件中，也可以集合日志收集系统直接将该错误用邮箱或者办公软件发送给你如：钉钉机器人+graylog. ## 中级版本 当然你也可以自己在log包里封装好可以接受channel。 利用channel通道，将go中出现的error传入到封装好的带有channel接受器..
golang-etl:使用Go进行ETL演示
04-30
演示：提取，转换和加载（16m 55s） 在Pluralsight课程上的这一课之后，我得到的最终代码版本的结果不...❯ go run main.go && cat dest.txt 13.690571ms Part Number Quantity Unit Cost Unit Price Total Cost Tota
Go-weixin-golang-sdk微信golang工具包
08-14
weixin-golang-sdk 微信golang工具包
golang-samples：使用Go编程语言为Google Cloud编写的示例应用程序和代码
02-04
Google Cloud Platform Go示例 该存储库包含用Go语言编写的示例代码，用于演示Google Cloud Platform。 一些示例在上具有随附的指南。 有关详细信息，请参见相应的自述文件。取决于样品将您需要的任何代码从该存储库...
golang手动实现error group
liyunlonghere
02-26 702
手动实现了下go error group，并发请求、请求数量限制、出错时cancel掉所有task，以下为示例，要求task是可cancel的！ package main import ( "context" "errors" "fmt" "sync" "sync/atomic" "time" ) const ( M = 2 N = 8 ) func main() { ctx, cancel := context.WithTimeout(context.Background.
golang中的errgroup
liuyuede123的博客
10-08 1119
假如我们需要查询一个课件列表，其中有课件的信息，还有课件创建者的信息，和课件的缩略图信息。但是此时我们已经对服务做了拆分，假设有课件服务和用户服务还有文件服务。 我们通常的做法是，当我们查询课件列表时，我们首先调用课件服务，比如查询10条课件记录，然后获取到课件的创建人ID，课件的缩略图ID；再通过这些创建人ID去用户服务查询用户信息，通过缩略图ID去文件服务查询文件信息；然后再写到这10条课件记录中返回给前端。
Go 语言 errgroup 包并发执行一组 goroutine ，并能够捕获这些 goroutine 中的任何错误
wgchen
06-02 289
Go 语言 errgroup 包并发执行一组 goroutine ，并能够捕获这些 goroutine 中的任何错误
golang errgroup
iUcool的博客
02-05 504
errgroup为goroutine组提供了通知、错误传递、上下文取消功能。一般在一组goroutine出现错误需要取消全部goroutine的情况使用到。
golang基于errgroup实现并发调用
夏日白云的boke
09-03 1093
本文介绍了Golang中errgroup的使用场景及方法
觉得WaitGroup不好用？试试ErrorGroup吧！
kevin_tech的博客，微信搜「网管叨bi叨」
12-23 1400
在并发编程里，sync.WaitGroup并发原语的使用频率非常高，经常用于协同等待场景：一个goroutine在检查点(Check Point)等待一组执行任务的 worker gor...
Go sync/errgroup 实例
Mr.Buffoon
12-26 3002
golang中增加了一个errgroup包，它在sync.WaitGroup功能的基础上，增加了错误传递，以及在发生不可恢复的错误时取消整个goroutine集合，或者等待超时。 其中包含的函数如下： func WithContext(ctx context.Context) (*Group, context.Context) func (g *Group) Go(f func() erro...
golang-lru 使用方法
04-29
golang-lru 是一个 Golang 语言实现的 LRU 缓存库，它提供了一个简单易用的 API 用于创建和使用 LRU 缓存。 下面是一个简单的使用示例： ```go package main import ( "fmt" "github.com/hashicorp/golang-lru"...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值