parallel

Documentation

Index

• type Future
  • func Go(ctx context.Context, fn func(ctx context.Context) (interface{}, error), ...) Future
• type Group
  • func GoGroup(ctx context.Context, opts ...RunOption) *Group
  • func (g *Group) Go(fn func(ctx context.Context) error)
  • func (g *Group) Wait() error
• type RunOption
  • func WithTimeout(timeout time.Duration) RunOption

Examples

• Group (JustErrors)
• Group (Parallel)

Types

type Future

type Future interface {
	Get() (interface{}, error)
	Cancel()
}

Future .

func Go

func Go(ctx context.Context, fn func(ctx context.Context) (interface{}, error), opts ...RunOption) Future

Go .

type Group

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

Group .

Example (JustErrors)

JustErrors illustrates the use of a Group in place of a sync.WaitGroup to simplify goroutine counting and error handling. This example is derived from the sync.WaitGroup example at https://golang.org/pkg/sync/#example_WaitGroup.

g := GoGroup(context.Background())
var urls = []string{
	"http://www.golang.org/",
	"http://www.google.com/",
	"http://www.somestupidname.com/",
}
for _, url := range urls {
	// Launch a goroutine to fetch the URL.
	url := url // https://golang.org/doc/faq#closures_and_goroutines
	g.Go(func(ctx context.Context) error {
		// Fetch the URL.
		resp, err := http.Get(url)
		if err == nil {
			resp.Body.Close()
		}
		return err
	})
}
// Wait for all HTTP fetches to complete.
if err := g.Wait(); err == nil {
	fmt.Println("Successfully fetched all URLs.")
}

Example (Parallel)

Parallel illustrates the use of a Group for synchronizing a simple parallel task: the "Google Search 2.0" function from https://talks.golang.org/2012/concurrency.slide#46, augmented with a Context and error-handling.

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

	g := GoGroup(context.Background())

	searches := []Search{Web, Image, Video}
	results := make([]Result, len(searches))
	for i, search := range searches {
		i, search := i, search // https://golang.org/doc/faq#closures_and_goroutines
		g.Go(func(ctx context.Context) error {
			result, err := search(ctx, query)
			if err == nil {
				results[i] = result
			}
			return err
		})
	}
	if err := g.Wait(); err != nil {
		return nil, err
	}
	return results, nil
}

results, err := Google(context.Background(), "golang")
if err != nil {
	fmt.Fprintln(os.Stderr, err)
	return
}
for _, result := range results {
	fmt.Println(result)
}

Output:

web result for "golang"
image result for "golang"
video result for "golang"

func GoGroup

func GoGroup(ctx context.Context, opts ...RunOption) *Group

GoGroup .

func (*Group) Go

func (g *Group) Go(fn func(ctx context.Context) error)

Go calls the given function in a new goroutine.

The first call to return a non-nil error cancels the group; its error will be returned by Wait.

func (*Group) Wait

func (g *Group) Wait() error

Wait blocks until all function calls from the Go method have returned, then returns the first non-nil error (if any) from them.

type RunOption

type RunOption func(opts *runOptions)

RunOption .

func WithTimeout

func WithTimeout(timeout time.Duration) RunOption

WithTimeout .