routine alternatives and similar packages
Based on the "Goroutines" category.
Alternatively, view routine alternatives based on common mentions on social networks and blogs.
-
semaphore
Semaphore pattern implementation with timeout of lock/unlock operations based on channel and context. -
Hunch
Hunch provides functions like: All, First, Retry, Waterfall etc., that makes asynchronous flow control more intuitive. -
goccm
Go Concurrency Manager package limits the number of goroutines that allowed to run concurrently. -
conexec
A concurrent toolkit to help execute funcs concurrently in an efficient and safe way.It supports specifying the overall timeout to avoid blocking and uses goroutine pool to improve efficiency. -
go-tools/multithreading
Manage a pool of goroutines using this lightweight library with a simple API. -
queue
Gives you a sync.WaitGroup like queue group accessibility. Helps you to throttle and limit goroutines, wait for the end of the all goroutines and much more. -
hands
A process controller used to control the execution and return strategies of multiple goroutines. -
concurrency-limiter
Concurrency limiter with support for timeouts , dynamic priority and context cancellation of goroutines. -
oversight
Oversight is a complete implementation of the Erlang supervision trees.
Get performance insights in less than 4 minutes
Do you think we are missing an alternative of routine or a related project?
Popular Comparisons
README
routine
Routine Architecture
[](docs/routine.png)
Quick Start
package main
import (
"log"
"context"
"github.com/x-mod/routine"
)
func main(){
if err := routine.Main(
context.TODO(),
routine.Command("echo", routine.ARG("hello routine!")),
); err != nil {
log.Fatal(err)
}
}
Or you can just clone the repo, then running go run quickstart/main.go
.
Main Routine
The most functional feature is providing the Main
function abstraction, you can use the routine.Main
to wrap your main function logic very quickly.
package main
import (
"context"
"github.com/x-mod/routine"
)
func MainGo(ctx context.Context) error {
log.Println("this is the Main Go func")
return nil
}
func ChildGo(ctx context.Context) error {
log.Println("this is the Child Go func")
return nil
}
func prepareGo(ctx context.Context) error {
log.Println("this is the prepare Go func")
return nil
}
func cleanupGo(ctx context.Context) error {
log.Println("this is the Clean Go func")
return nil
}
func main(){
log.Println(
routine.Main(
context.TODO(),
//main Go
routine.ExecutorFunc(MainGo),
//prpare Go
routine.Prepare(routine.ExecutorFunc(prepareGo)),
//cleanup Go
routine.Cleanup(routine.ExecutorFunc(cleanupGo)),
routine.Go(routine.ExecutorFunc(ChildGo)),//child Go
routine.Go(routine.ExecutorFunc(ChildGo)),
routine.Go(routine.ExecutorFunc(ChildGo)),
//signals
routine.Signal(syscall.SIGINT, routine.SigHandler(func() {
os.Exit(1)
})),
),
)
}
Routine
create and control your own routine by routine.New
.
import "github.com/x-mod/routine"
err := routine.New(opts...).Execute(ctx)
Executors
The package provides many useful executor adapters for you:
- guarantee
- timeout & deadline
- retry & repeat
- concurrent
- crontab
- parallel & sequence
- command
- profiling
with these executor adapters, you can building the most complex goroutine logic.
import "github.com/x-mod/routine"
//timeout
timeout := routine.Timeout(time.Minute, exec)
//retry
retry := routine.Retry(3, exec)
//repeat
repeat := routine.Repeat(10, time.Second, exec)
//concurrent
concurrent := routine.Concurrent(4, exec)
//schedule executor
crontab := routine.Crontab("* * * * *", exec)
//command
command := routine.Command("echo", routine.ARG("hello routine!"))
//parallel
parallel := routine.Parallel(exec1, exec2, exec3, ...)
//sequence
sequece := routine.Append(exec1, exec2, exec3, ...)
Enjoy
More details, please check the [example](example/main.go) and trace it.
$: go run example/main.go
# trace go routine & tasks
$: go tool trace trace.out
Then you can check the tasks like this:
[](docs/usetasks.png)