go-errgroup使用

已于 2022-08-30 14:13:16 修改
阅读量1.5k 收藏 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
关注
Go语言中如何正确使用 errgroup
禅与代码的艺术
04-13 1101
在Go语言中如何使用 errgroup
理解 Go 语言的分组操作
最新发布
禅与代码的艺术
08-09 1076
理解 Go 语言分组操作
Go语言ErrGroup
YIYIYI
07-14 1979
Go语言ErrGroup
go errgroup 用法示例
papaya的博客
07-23 9752
Go团队在实验仓库中添加了一个名为sync.errgroup的新软件包。 sync.ErrGroup再sync.WaitGroup功能的基础上，增加了错误传递，以及在发生不可恢复的错误时取消整个goroutine集合，或者等待超时 其中包含的函数如下： func WithContext(ctx context.Context) (*Group, context.Context) Go(...
并发编程包之 errgroup
qq_39397165的博客
08-05 676
欢迎大家点击上方文字「Golang梦工厂」关注公众号，设为星标，第一时间接收推送文章。前言哈喽，大家好，我是asong，今天给大家介绍一个并发编程包errgroup，其实这个包就是对syn...
go并发小工具errgroup
柳清风的专栏
12-30 821
先看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 {
【GoCN酷Go推荐】 errgroup 并发小工具
Go中国
04-30 431
使用场景：微服务中的并发请求并发编程是Golang语言的强大特性之一。在微服务架构中，面对用户的请求，我们常常需要向下游请求大量的数据继而组装成所需数据，不同的数据很可能会由不同的服务提供...
go 并发模型 之 errgroup （六）
aa2533004938的博客
11-04 299
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 前言 errgroup 适用于 需获取多个接口的数据进行汇总 go 天然的支持并发 所以这种场景 是不是也可以使用并发来处理呢？？ 一、errgroup 源码 通过WithContext可以创建一个带取消的Group Go方法传入一个func() error内部会启动一个 goroutine 去处理 Wait类似 WaitGroup 的 Wait 方法，等待所有的 goroutine 结束后退出...
study-go-train-camp:golang训练营学习
03-18
golang训练营学习总结 介绍 网络服务标准工程 功能 ...并发的使用（errgroup的并行互连请求 微服务中间件的使用（ELK，Opentracing，Prometheus，Kafka） 缓存的使用优化（一致性处理，管道优化 笔记
golang errgroup的用法及用处
热门推荐
程序员面试精选【codeoffer】
10-12 1万+
一般在golang 中想要并发运行业务时会直接开goroutine，关键字go ,但是直接go的话函数是无法对返回数据进行处理error的。 解决方案： ## 初级版本： 一般是直接在出错的地方打入log日志,将出的错误记录到日志文件中，也可以集合日志收集系统直接将该错误用邮箱或者办公软件发送给你如：钉钉机器人+graylog. ## 中级版本 当然你也可以自己在log包里封装好可以接受channel。 利用channel通道，将go中出现的error传入到封装好的带有channel接受器..
【Golang】使用Golang使用errorgroup
tr6666的博客
04-15 660
在并发编程中，我们经常会遇到这样的场景：启动多个 goroutine 去并发处理任务，如果其中一个出错，其他的都应该被取消。在 Go 语言中，我们可以使用 errgroup 包来简化这种模式的实现。errgroup 提供了一种优雅的方式来处理并发任务中的错误。它允许我们并发执行多个任务，并在任何一个任务失败时取消所有任务。这可以帮助我们编写出更加健壮和易于理解的并发代码。如果你在使用 Go 进行并发编程，我强烈建议你试试 errgroup。
【Go】扩展并发原语之errgroup.Group的实战与源码解读
TomCN0803的博客
01-31 1288
虽然提供了对错误的返回，但是只能返回所有启动的 goroutine 产生的第一个错误，如果不做额外扩展的话后面所产生的错误都会被丢弃，然而在很多时候，获取每个 goroutine 的错误情况又是很必要的。是将输入文本转化为可读 channel，后三者则分别对应了 MapReduce 的三个步骤，它们每个步骤所产生的 channel 都作为下一步操作的输入 channel，会将数据全部存于内存中，在实际生产中可能会遇到很大的文件，这时候我们就需要考虑其它的堆实现方式了，不过这不是本文的重点。
golang手动实现error group
liyunlonghere
02-26 721
手动实现了下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 1158
假如我们需要查询一个课件列表，其中有课件的信息，还有课件创建者的信息，和课件的缩略图信息。但是此时我们已经对服务做了拆分，假设有课件服务和用户服务还有文件服务。 我们通常的做法是，当我们查询课件列表时，我们首先调用课件服务，比如查询10条课件记录，然后获取到课件的创建人ID，课件的缩略图ID；再通过这些创建人ID去用户服务查询用户信息，通过缩略图ID去文件服务查询文件信息；然后再写到这10条课件记录中返回给前端。
Go 语言 errgroup 包并发执行一组 goroutine ，并能够捕获这些 goroutine 中的任何错误
wgchen
06-02 322
Go 语言 errgroup 包并发执行一组 goroutine ，并能够捕获这些 goroutine 中的任何错误
golang errgroup
iUcool的博客
02-05 528
errgroup为goroutine组提供了通知、错误传递、上下文取消功能。一般在一组goroutine出现错误需要取消全部goroutine的情况使用到。
golang基于errgroup实现并发调用
夏日白云的boke
09-03 1188
本文介绍了Golang中errgroup的使用场景及方法
觉得WaitGroup不好用？试试ErrorGroup吧！
kevin_tech的博客，微信搜「网管叨bi叨」
12-23 1456
在并发编程里，sync.WaitGroup并发原语的使用频率非常高，经常用于协同等待场景：一个goroutine在检查点(Check Point)等待一组执行任务的 worker gor...
Go语言包universal-translator使用指南
- 使用Go语言开发，依赖于Go的简洁语法和强大的并发处理能力。 - 该包支持HTTP/HTTPS协议，实现对翻译API的调用。 - 该包可能使用了机器学习或深度学习技术，以提供高质量的翻译结果。 4. 应用场景： - universal-...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值