Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/pieterclaerhout/go-waitgroup
A sync.WaitGroup with error handling and concurrency control
https://github.com/pieterclaerhout/go-waitgroup
concurrency golang goroutine goroutines pool waitgroup
Last synced: about 1 month ago
JSON representation
A sync.WaitGroup with error handling and concurrency control
- Host: GitHub
- URL: https://github.com/pieterclaerhout/go-waitgroup
- Owner: pieterclaerhout
- License: apache-2.0
- Created: 2018-08-08T16:12:35.000Z (over 6 years ago)
- Default Branch: master
- Last Pushed: 2024-06-24T06:12:39.000Z (6 months ago)
- Last Synced: 2024-07-31T20:51:53.369Z (5 months ago)
- Topics: concurrency, golang, goroutine, goroutines, pool, waitgroup
- Language: Go
- Homepage: https://www.yellowduck.be
- Size: 38.1 KB
- Stars: 46
- Watchers: 3
- Forks: 4
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
- awesome-go - go-waitgroup - Like `sync.WaitGroup` with error handling and concurrency control. (Goroutines / Search and Analytic Databases)
- awesome-go-extra - go-waitgroup - 08-08T16:12:35Z|2020-02-21T09:12:59Z| (Goroutines / Advanced Console UIs)
README
# go-waitgroup
[](https://github.com/pieterclaerhout/go-waitgroup/actions?query=workflow%3AGo)
[](https://goreportcard.com/report/github.com/pieterclaerhout/go-waitgroup)
[](http://godoc.org/github.com/pieterclaerhout/go-waitgroup)
[](https://github.com/pieterclaerhout/go-waitgroup/raw/master/LICENSE)
[](https://badge.fury.io/gh/pieterclaerhout%2Fgo-waitgroup)
[](https://github.com/pieterclaerhout/go-waitgroup/issues)
## How to use
An package that allows you to use the constructs of a [`sync.WaitGroup`](https://golang.org/pkg/sync/#WaitGroup) to
create a pool of goroutines and control the concurrency.
Using it is just like a normal [`sync.WaitGroup`](https://golang.org/pkg/sync/#WaitGroup). The only difference is the initialisation. When you use `waitgroup.NewWaitGroup`, you have the option to specify it's size.
Any `int` which is bigger than `0` will limit the number of concurrent goroutines. If you specify `-1` or `0`, all goroutines will run at once (just like a plain [`sync.WaitGroup`](https://golang.org/pkg/sync/#WaitGroup)).
```go
package main
import (
"fmt"
"net/http"
"github.com/pieterclaerhout/go-waitgroup"
)
func main() {
urls := []string{
"https://www.easyjet.com/",
"https://www.skyscanner.de/",
"https://www.ryanair.com",
"https://wizzair.com/",
"https://www.swiss.com/",
}
wg := waitgroup.NewWaitGroup(3)
for _, url := range urls {
wg.BlockAdd()
go func(url string) {
defer wg.Done()
fmt.Printf("%s: checking\n", url)
res, err := http.Get(url)
if err != nil {
fmt.Println("Error: %v")
} else {
defer res.Body.Close()
fmt.Printf("%s: result: %v\n", url, err)
}
}(url)
}
wg.Wait()
fmt.Println("Finished")
}
```
## Using closures
There is also a way to use function closures to make it even more readable:
```go
package main
import (
"fmt"
"net/http"
"github.com/pieterclaerhout/go-waitgroup"
)
func main() {
urls := []string{
"https://www.easyjet.com/",
"https://www.skyscanner.de/",
"https://www.ryanair.com",
"https://wizzair.com/",
"https://www.swiss.com/",
}
wg := waitgroup.NewWaitGroup(3)
for _, url := range urls {
urlToCheck := url
wg.Add(func() {
fmt.Printf("%s: checking\n", urlToCheck)
res, err := http.Get(urlToCheck)
if err != nil {
fmt.Println("Error: %v")
} else {
defer res.Body.Close()
fmt.Printf("%s: result: %v\n", urlToCheck, err)
}
})
}
wg.Wait()
fmt.Println("Finished")
}
```
## Handling errors
If you want to handle errors, there is also an `ErrorGroup`. This uses the same principles as a normal `WaitGroup` with a small twist.
First of all, you can only add functions which returns just an `error`.
Second, as soon as one of the queued items fail, the rest will be cancelled:
```go
package main
import (
"context"
"fmt"
"os"
"github.com/pieterclaerhout/go-waitgroup"
)
func main() {
ctx := context.Background()
wg, ctx := waitgroup.NewErrorGroup(ctx, tc.size)
if err != nil {
fmt.Println("Error: %v")
os.Exit(1)
}
wg.Add(func() error {
return nil
})
wg.Add(func() error {
return errors.New("An error occurred")
})
if err := wg.Wait(); err != nil {
fmt.Println("Error: %v")
os.Exit(1)
}
}
```
You can also add multiple functions in one step:
```go
package main
import (
"context"
"errors"
"fmt"
"os"
"github.com/pieterclaerhout/go-waitgroup"
)
func main() {
ctx := context.Background()
wg, ctx := waitgroup.NewErrorGroup(ctx, tc.size)
if err != nil {
fmt.Println("Error: %v")
os.Exit(1)
}
wg.Add(
func() error {
return nil
},
func() error {
return errors.New("An error occurred")
},
)
if err := wg.Wait(); err != nil {
fmt.Println("Error: %v")
os.Exit(1)
}
}
```