package main

import (
    "fmt"
    "net/http"
    "sync"
)

func main() {
    var urls = []string{
        "http://www.golang.org/",
        "http://www.google.com/",
        "http://www.somestupidname.com/", // 這是一個(gè)錯(cuò)誤的 URL，會(huì)導(dǎo)致任務(wù)失敗
    }
    var err error

    var wg sync.WaitGroup // 零值可用，不必顯式初始化

    for _, url := range urls {
        wg.Add(1) // 增加 WaitGroup 計(jì)數(shù)器

        // 啟動(dòng)一個(gè) goroutine 來獲取 URL
        go func() {
            defer wg.Done() // 當(dāng) goroutine 完成時(shí)遞減 WaitGroup 計(jì)數(shù)器

            resp, e := http.Get(url)
            if e != nil { // 發(fā)生錯(cuò)誤返回，并記錄該錯(cuò)誤
                err = e
                return
            }
            defer resp.Body.Close()
            fmt.Printf("fetch url %s status %s\n", url, resp.Status)
        }()
    }

    // 等待所有 goroutine 執(zhí)行完成
    wg.Wait()
    if err != nil { // err 會(huì)記錄最后一個(gè)錯(cuò)誤
        fmt.Printf("Error: %s\n", err)
    }
}

var wg sync.WaitGroup

for ... {
    wg.Add(1)

    go func() {
        defer wg.Done()
        // do something
    }()
}

wg.Wait()

package main

import (
    "fmt"
    "net/http"

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

func main() {
    var urls = []string{
        "http://www.golang.org/",
        "http://www.google.com/",
        "http://www.somestupidname.com/", // 這是一個(gè)錯(cuò)誤的 URL，會(huì)導(dǎo)致任務(wù)失敗
    }

    // 使用 errgroup 創(chuàng)建一個(gè)新的 goroutine 組
    var g errgroup.Group // 零值可用，不必顯式初始化

    for _, url := range urls {
        // 使用 errgroup 啟動(dòng)一個(gè) goroutine 來獲取 URL
        g.Go(func() error {
            resp, err := http.Get(url)
            if err != nil {
                return err // 發(fā)生錯(cuò)誤，返回該錯(cuò)誤
            }
            defer resp.Body.Close()
            fmt.Printf("fetch url %s status %s\n", url, resp.Status)
            return nil // 返回 nil 表示成功
        })
    }

    // 等待所有 goroutine 完成并返回第一個(gè)錯(cuò)誤（如果有）
    if err := g.Wait(); err != nil {
        fmt.Printf("Error: %s\n", err)
    }
}

package main

import (
    "context"
    "fmt"
    "net/http"
    "sync"

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

func main() {
    var urls = []string{
        "http://www.golang.org/",
        "http://www.google.com/",
        "http://www.somestupidname.com/", // 這是一個(gè)錯(cuò)誤的 URL，會(huì)導(dǎo)致任務(wù)失敗
    }

    // 創(chuàng)建一個(gè)帶有 context 的 errgroup
    // 任何一個(gè) goroutine 返回非 nil 的錯(cuò)誤，或 Wait() 等待所有 goroutine 完成后，context 都會(huì)被取消
    g, ctx := errgroup.WithContext(context.Background())

    // 創(chuàng)建一個(gè) map 來保存結(jié)果
    var result sync.Map

    for _, url := range urls {
        // 使用 errgroup 啟動(dòng)一個(gè) goroutine 來獲取 URL
        g.Go(func() error {
            req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
            if err != nil {
                return err // 發(fā)生錯(cuò)誤，返回該錯(cuò)誤
            }

            // 發(fā)起請(qǐng)求
            resp, err := http.DefaultClient.Do(req)
            if err != nil {
                return err // 發(fā)生錯(cuò)誤，返回該錯(cuò)誤
            }
            defer resp.Body.Close()

            // 保存每個(gè) URL 的響應(yīng)狀態(tài)碼
            result.Store(url, resp.Status)
            return nil // 返回 nil 表示成功
        })
    }

    // 等待所有 goroutine 完成并返回第一個(gè)錯(cuò)誤（如果有）
    if err := g.Wait(); err != nil {
        fmt.Println("Error: ", err)
    }

    // 所有 goroutine 都執(zhí)行完成，遍歷并打印成功的結(jié)果
    result.Range(func(key, value any) bool {
        fmt.Printf("fetch url %s status %s\n", key, value)
        return true
    })
}

package main

import (
    "fmt"
    "time"

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

func main() {
    // 創(chuàng)建一個(gè) errgroup.Group
    var g errgroup.Group
    // 設(shè)置最大并發(fā)限制為 3
    g.SetLimit(3)

    // 啟動(dòng) 10 個(gè) goroutine
    for i := 1; i <= 10; i++ {
        g.Go(func() error {
            // 打印正在運(yùn)行的 goroutine
            fmt.Printf("Goroutine %d is starting\n", i)
            time.Sleep(2 * time.Second) // 模擬任務(wù)耗時(shí)
            fmt.Printf("Goroutine %d is done\n", i)
            return nil
        })
    }

    // 等待所有 goroutine 完成
    if err := g.Wait(); err != nil {
        fmt.Printf("Encountered an error: %v\n", err)
    }

    fmt.Println("All goroutines complete.")
}

package main

import (
    "fmt"
    "time"

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

func main() {
    // 創(chuàng)建一個(gè) errgroup.Group
    var g errgroup.Group
    // 設(shè)置最大并發(fā)限制為 3
    g.SetLimit(3)

    // 啟動(dòng) 10 個(gè) goroutine
    for i := 1; i <= 10; i++ {
        if g.TryGo(func() error {
            // 打印正在運(yùn)行的 goroutine
            fmt.Printf("Goroutine %d is starting\n", i)
            time.Sleep(2 * time.Second) // 模擬工作
            fmt.Printf("Goroutine %d is done\n", i)
            return nil
        }) {
            // 如果成功啟動(dòng)，打印提示
            fmt.Printf("Goroutine %d started successfully\n", i)
        } else {
            // 如果達(dá)到并發(fā)限制，打印提示
            fmt.Printf("Goroutine %d could not start (limit reached)\n", i)
        }
    }

    // 等待所有 goroutine 完成
    if err := g.Wait(); err != nil {
        fmt.Printf("Encountered an error: %v\n", err)
    }

    fmt.Println("All goroutines complete.")
}

// Copyright 2016 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Package errgroup provides synchronization, error propagation, and Context
// cancelation for groups of goroutines working on subtasks of a common task.
//
// [errgroup.Group] is related to [sync.WaitGroup] but adds handling of tasks
// returning errors.
package errgroup

import (
    "context"
    "fmt"
    "sync"
)

type token struct{}

// A Group is a collection of goroutines working on subtasks that are part of
// the same overall task.
//
// A zero Group is valid, has no limit on the number of active goroutines,
// and does not cancel on error.
type Group struct {
    cancel func(error)

    wg sync.WaitGroup

    sem chan token

    errOnce sync.Once
    err     error
}

func (g *Group) done() {
    if g.sem != nil {
        <-g.sem
    }
    g.wg.Done()
}

// WithContext returns a new Group and an associated Context derived from ctx.
//
// The derived Context is canceled the first time a function passed to Go
// returns a non-nil error or the first time Wait returns, whichever occurs
// first.
func WithContext(ctx context.Context) (*Group, context.Context) {
    ctx, cancel := withCancelCause(ctx)
    return &Group{cancel: cancel}, ctx
}

// Wait blocks until all function calls from the Go method have returned, then
// returns the first non-nil error (if any) from them.
func (g *Group) Wait() error {
    g.wg.Wait()
    if g.cancel != nil {
        g.cancel(g.err)
    }
    return g.err
}

// Go calls the given function in a new goroutine.
// It blocks until the new goroutine can be added without the number of
// active goroutines in the group exceeding the configured limit.
//
// The first call to return a non-nil error cancels the group's context, if the
// group was created by calling WithContext. The error will be returned by Wait.
func (g *Group) Go(f func() error) {
    if g.sem != nil {
        g.sem <- token{}
    }

    g.wg.Add(1)
    go func() {
        defer g.done()

        if err := f(); err != nil {
            g.errOnce.Do(func() {
                g.err = err
                if g.cancel != nil {
                    g.cancel(g.err)
                }
            })
        }
    }()
}

// TryGo calls the given function in a new goroutine only if the number of
// active goroutines in the group is currently below the configured limit.
//
// The return value reports whether the goroutine was started.
func (g *Group) TryGo(f func() error) bool {
    if g.sem != nil {
        select {
        case g.sem <- token{}:
            // Note: this allows barging iff channels in general allow barging.
        default:
            return false
        }
    }

    g.wg.Add(1)
    go func() {
        defer g.done()

        if err := f(); err != nil {
            g.errOnce.Do(func() {
                g.err = err
                if g.cancel != nil {
                    g.cancel(g.err)
                }
            })
        }
    }()
    return true
}

// SetLimit limits the number of active goroutines in this group to at most n.
// A negative value indicates no limit.
//
// Any subsequent call to the Go method will block until it can add an active
// goroutine without exceeding the configured limit.
//
// The limit must not be modified while any goroutines in the group are active.
func (g *Group) SetLimit(n int) {
    if n < 0 {
        g.sem = nil
        return
    }
    if len(g.sem) != 0 {
        panic(fmt.Errorf("errgroup: modify limit while %v goroutines in the group are still active", len(g.sem)))
    }
    g.sem = make(chan token, n)
}

// Copyright 2023 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

//go:build go1.20

package errgroup

import "context"

func withCancelCause(parent context.Context) (context.Context, func(error)) {
    return context.WithCancelCause(parent)
}

// Copyright 2023 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

//go:build !go1.20

package errgroup

import "context"

func withCancelCause(parent context.Context) (context.Context, func(error)) {
    ctx, cancel := context.WithCancel(parent)
    return ctx, func(error) { cancel() }
}

// 定義一個(gè)空結(jié)構(gòu)體類型 token，會(huì)作為信號(hào)進(jìn)行傳遞，用于控制并發(fā)數(shù)
type token struct{}

// Group 是一組協(xié)程的集合，這些協(xié)程處理同一整體任務(wù)的子任務(wù)
//
// 零值 Group 是有效的，對(duì)活動(dòng)協(xié)程的數(shù)量沒有限制，并且不會(huì)在出錯(cuò)時(shí)取消
type Group struct {
    cancel func(error) // 取消函數(shù)，就是 context.CancelCauseFunc 類型

    wg sync.WaitGroup // 內(nèi)部使用了 sync.WaitGroup

    sem chan token // 信號(hào) channel，可以控制協(xié)程并發(fā)數(shù)量

    errOnce sync.Once // 確保錯(cuò)誤僅處理一次
    err     error     // 記錄子協(xié)程集中返回的第一個(gè)錯(cuò)誤
}

// SetLimit 限制該 Group 中活動(dòng)的協(xié)程數(shù)量最多為 n，負(fù)值表示沒有限制
//
// 任何后續(xù)對(duì) Go 方法的調(diào)用都將阻塞，直到可以在不超過限額的情況下添加活動(dòng)協(xié)程
//
// 在 Group 中存在任何活動(dòng)的協(xié)程時(shí)，限制不得修改
func (g *Group) SetLimit(n int) { // 傳進(jìn)來的 n 就是 channel 長(zhǎng)度，以此來限制協(xié)程的并發(fā)數(shù)量
    if n < 0 { // 這里檢查如果小于 0 則不限制協(xié)程并發(fā)數(shù)量。此外，也不要將其設(shè)置為 0，會(huì)產(chǎn)生死鎖
        g.sem = nil
        return
    }
    if len(g.sem) != 0 { // 如果存在活動(dòng)的協(xié)程，調(diào)用此方法將產(chǎn)生 panic
        panic(fmt.Errorf("errgroup: modify limit while %v goroutines in the group are still active", len(g.sem)))
    }
    g.sem = make(chan token, n)
}

// Go 會(huì)在新的協(xié)程中調(diào)用給定的函數(shù)
// 它會(huì)阻塞，直到可以在不超過配置的活躍協(xié)程數(shù)量限制的情況下添加新的協(xié)程
//
// 首次返回非 nil 錯(cuò)誤的調(diào)用會(huì)取消該 Group 的上下文（context），如果該 context 是通過調(diào)用 WithContext 創(chuàng)建的，該錯(cuò)誤將由 Wait 返回
func (g *Group) Go(f func() error) {
    if g.sem != nil { // 這個(gè)是限制并發(fā)數(shù)的信號(hào)通道
        g.sem <- token{} // 如果超過了配置的活躍協(xié)程數(shù)量限制，向 channel 發(fā)送 token 會(huì)阻塞
    }

    g.wg.Add(1) // 轉(zhuǎn)發(fā)給 sync.WaitGroup.Add(1)，將活動(dòng)協(xié)程數(shù)加一
    go func() {
        defer g.done() // 當(dāng)一個(gè)協(xié)程完成時(shí)，調(diào)用此方法，內(nèi)部會(huì)將調(diào)用轉(zhuǎn)發(fā)給 sync.WaitGroup.Done()

        if err := f(); err != nil { // f() 就是我們要執(zhí)行的任務(wù)
            g.errOnce.Do(func() { // 僅執(zhí)行一次，即只處理一次錯(cuò)誤，所以會(huì)記錄第一個(gè)非 nil 的錯(cuò)誤，與協(xié)程啟動(dòng)順序無關(guān)
                g.err = err          // 記錄錯(cuò)誤
                if g.cancel != nil { // 如果 cancel 不為 nil，則調(diào)用取消函數(shù)，并設(shè)置 cause
                    g.cancel(g.err)
                }
            })
        }
    }()
}

// 當(dāng)一個(gè)協(xié)程完成時(shí)，調(diào)用此方法
func (g *Group) done() {
    // 如果設(shè)置了最大并發(fā)數(shù)，則 sem 不為 nil，從 channel 中消費(fèi)一個(gè) token，表示一個(gè)協(xié)程已完成
    if g.sem != nil {
        <-g.sem
    }
    g.wg.Done() // 轉(zhuǎn)發(fā)給 sync.WaitGroup.Done()，將活動(dòng)協(xié)程數(shù)減一
}

// WithContext 返回一個(gè)新的 Group 和一個(gè)從 ctx 派生的關(guān)聯(lián) Context
//
// 派生的 Context 會(huì)在傳遞給 Go 的函數(shù)首次返回非 nil 錯(cuò)誤或 Wait 首次返回時(shí)被取消，以先發(fā)生者為準(zhǔn)。
func WithContext(ctx context.Context) (*Group, context.Context) {
    ctx, cancel := withCancelCause(ctx)
    return &Group{cancel: cancel}, ctx
}

// 構(gòu)建約束標(biāo)識(shí)了這個(gè)文件是 Go 1.20 版本被加入的
//go:build go1.20

package errgroup

import "context"

// 代理到 context.WithCancelCause
func withCancelCause(parent context.Context) (context.Context, func(error)) {
    return context.WithCancelCause(parent)
}

//go:build !go1.20

package errgroup

import "context"

func withCancelCause(parent context.Context) (context.Context, func(error)) {
    ctx, cancel := context.WithCancel(parent)
    return ctx, func(error) { cancel() }
}

// Wait 會(huì)阻塞，直到來自 Go 方法的所有函數(shù)調(diào)用返回，然后返回它們中的第一個(gè)非 nil 錯(cuò)誤（如果有的話）
func (g *Group) Wait() error {
    g.wg.Wait()          // 轉(zhuǎn)發(fā)給 sync.WaitGroup.Wait()，等待所有協(xié)程執(zhí)行完成
    if g.cancel != nil { // 如果 cancel 不為 nil，則調(diào)用取消函數(shù)，并設(shè)置 cause
        g.cancel(g.err)
    }
    return g.err // 返回錯(cuò)誤
}

// TryGo 僅在 Group 中活動(dòng)的協(xié)程數(shù)量低于限額時(shí)，才在新的協(xié)程中調(diào)用給定的函數(shù)
//
// 返回值標(biāo)識(shí)協(xié)程是否啟動(dòng)
func (g *Group) TryGo(f func() error) bool {
    if g.sem != nil { // 如果設(shè)置了最大并發(fā)數(shù)
        select {
        case g.sem <- token{}: // 可以向 channel 寫入 token，說明沒有達(dá)到限額，可以啟動(dòng)協(xié)程
            // Note: this allows barging iff channels in general allow barging.
        default: // 如果超過了配置的活躍協(xié)程數(shù)量限制，會(huì)走到這個(gè) case
            return false
        }
    }

    // 接下來的代碼與 Go 中的邏輯相同
    g.wg.Add(1)
    go func() {
        defer g.done()

        if err := f(); err != nil {
            g.errOnce.Do(func() {
                g.err = err
                if g.cancel != nil {
                    g.cancel(g.err)
                }
            })
        }
    }()
    return true
}