Skip to content

Simple concurrency with early cancelation in go

Notifications You must be signed in to change notification settings

heyimalex/spara

Folders and files

NameName
Last commit message
Last commit date

Latest commit

 

History

15 Commits
 
 
 
 
 
 
 
 

Repository files navigation

spara GoDoc

Concurrently map over slices in go, with early cancellation on error.

go get github.com/heyimalex/spara

NOTE: This package requires go 1.7+ as it depends on context.

Usage

You have an array of things, and you want to "process" those things concurrently, stopping early if any of those things fails to process. Use spara like this.

const workers = 5                   // Number of worker goroutines to spawn
inputs := []int{1, 2, 3, 4, 5}      // Your things
results := make([]int, len(inputs)) // Place for your results

// Run will call the passed function with every index of the input slice.
spara.Run(workers, len(inputs), func(index int) error {
    input := inputs[index]  // Access the thing
    result := input * 2     // Process the thing
    results[index] = result // Store the result
    return nil              // Return an error if you like
})

fmt.Println(results)
// Output: [2 4 6 8 10]

This package also has support for go's context.Context, so your processing function can know when it's time to quit.

parent, cancel := context.WithTimeout(context.Background(), time.Millisecond * 10)
defer cancel()

err := spara.RunWithContext(parent, 5, 50, func(ctx context.Context, idx int) error {
    <-ctx.Done()
    return ctx.Err()
})

fmt.Println(err)
// Output:  context deadline exceeded

Read more in the godoc.

About

Simple concurrency with early cancelation in go

Resources

Stars

Watchers

Forks

Releases

No releases published

Packages

No packages published

Languages