Popularity
1.1
Growing
Activity
6.3
Declining
8
1
1

Programming language: Go
Tags: Goroutines    
Latest version: v1.2.10

routine alternatives and similar packages

Based on the "Goroutines" category

Do you think we are missing an alternative of routine or a related project?

Add another 'Goroutines' Package

README

routine

GoDoc Go Report Card Build Status Version Coverage Status

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.Interrupts(routine.DefaultCancelInterruptors...),
        ),
    )
}

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)