package conc

import "github.com/sourcegraph/conc"

Index ¶

• type WaitGroup
• func NewWaitGroup() *WaitGroup
• func (h *WaitGroup) Go(f func())
• func (h *WaitGroup) Wait()
• func (h *WaitGroup) WaitAndRecover() *panics.Recovered

Examples ¶

• WaitGroup
• WaitGroup.WaitAndRecover

Types ¶

type WaitGroup ¶

type WaitGroup struct {
	// contains filtered or unexported fields
}

WaitGroup is the primary building block for scoped concurrency. Goroutines can be spawned in the WaitGroup with the Go method, and calling Wait() will ensure that each of those goroutines exits before continuing. Any panics in a child goroutine will be caught and propagated to the caller of Wait().

The zero value of WaitGroup is usable, just like sync.WaitGroup. Also like sync.WaitGroup, it must not be copied after first use.

{
	var count atomic.Int64

	var wg WaitGroup
	for i := 0; i < 10; i++ {
		wg.Go(func() {
			count.Add(1)
		})
	}
	wg.Wait()

	fmt.Println(count.Load())
	// Output:
	// 10
}

10

func NewWaitGroup ¶

func NewWaitGroup() *WaitGroup

NewWaitGroup creates a new WaitGroup.

func (*WaitGroup) Go ¶

func (h *WaitGroup) Go(f func())

Go spawns a new goroutine in the WaitGroup.

func (*WaitGroup) Wait ¶

func (h *WaitGroup) Wait()

Wait will block until all goroutines spawned with Go exit and will propagate any panics spawned in a child goroutine.

func (*WaitGroup) WaitAndRecover ¶

func (h *WaitGroup) WaitAndRecover() *panics.Recovered

WaitAndRecover will block until all goroutines spawned with Go exit and will return a *panics.Recovered if one of the child goroutines panics.

{
	var wg WaitGroup

	wg.Go(func() {
		panic("super bad thing")
	})

	recoveredPanic := wg.WaitAndRecover()
	fmt.Println(recoveredPanic.Value)
	// Output:
	// super bad thing
}

super bad thing

Source Files ¶

waitgroup.go

Directories ¶