Hunch - Golang异步流程控制库

Hunch是一个让Golang异步流程控制更直观的插件库，它提供了类似JavaScript中Promise的链式调用风格，使得异步代码更易读和维护。

主要特性

1. 链式调用风格
2. 支持并行执行
3. 支持顺序执行
4. 错误处理机制
5. 超时控制

安装

go get github.com/AaronJan/Hunch

基本使用示例

1. 并行执行多个任务

package main

import (
	"context"
	"fmt"
	"time"

	"github.com/AaronJan/Hunch"
)

func main() {
	ctx := context.Background()
	
	results, errors := Hunch.All(
		ctx,
		func(ctx context.Context) (interface{}, error) {
			time.Sleep(2 * time.Second)
			return "Task 1", nil
		},
		func(ctx context.Context) (interface{}, error) {
			time.Sleep(1 * time.Second)
			return "Task 2", nil
		},
		func(ctx context.Context) (interface{}, error) {
			time.Sleep(3 * time.Second)
			return 100, nil
		},
	)

	for i, result := range results {
		fmt.Printf("Result %d: %v\n", i, result)
	}
	
	if len(errors) > 0 {
		fmt.Println("Errors occurred:", errors)
	}
}

2. 顺序执行任务

package main

import (
	"context"
	"fmt"
	"time"

	"github.com/AaronJan/Hunch"
)

func main() {
	ctx := context.Background()
	
	results, errors := Hunch.Waterfall(
		ctx,
		func(ctx context.Context, n interface{}) (interface{}, error) {
			fmt.Println("First task")
			return "initial data", nil
		},
		func(ctx context.Context, n interface{}) (interface{}, error) {
			fmt.Println("Second task received:", n)
			time.Sleep(1 * time.Second)
			return "processed data", nil
		},
		func(ctx context.Context, n interface{}) (interface{}, error) {
			fmt.Println("Third task received:", n)
			return "final result", nil
		},
	)

	fmt.Println("Final result:", results)
	if len(errors) > 0 {
		fmt.Println("Errors occurred:", errors)
	}
}

3. 带超时控制的并行任务

package main

import (
	"context"
	"fmt"
	"time"

	"github.com/AaronJan/Hunch"
)

func main() {
	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
	defer cancel()
	
	results, errors := Hunch.All(
		ctx,
		func(ctx context.Context) (interface{}, error) {
			time.Sleep(3 * time.Second) // 这个任务会超时
			return "Task 1", nil
		},
		func(ctx context.Context) (interface{}, error) {
			time.Sleep(1 * time.Second)
			return "Task 2", nil
		},
	)

	fmt.Println("Results:", results)
	fmt.Println("Errors:", errors) // 会包含context deadline exceeded错误
}

4. 链式调用

package main

import (
	"context"
	"fmt"
	"time"

	"github.com/AaronJan/Hunch"
)

func main() {
	ctx := context.Background()
	
	Hunch.New(ctx).
		Then(func(ctx context.Context) (interface{}, error) {
			fmt.Println("First task")
			return 10, nil
		}).
		Then(func(ctx context.Context, n interface{}) (interface{}, error) {
			num := n.(int)
			fmt.Println("Got number:", num)
			return num * 2, nil
		}).
		Then(func(ctx context.Context, n interface{}) (interface{}, error) {
			num := n.(int)
			fmt.Println("Final number:", num)
			return nil, nil
		}).
		Catch(func(ctx context.Context, err error) (interface{}, error) {
			fmt.Println("Error occurred:", err)
			return nil, err
		}).
		Finally(func(ctx context.Context, n interface{}) (interface{}, error) {
			fmt.Println("All done")
			return nil, nil
		})
}

高级用法

1. 限制并发数

package main

import (
	"context"
	"fmt"
	"time"

	"github.com/AaronJan/Hunch"
)

func main() {
	ctx := context.Background()
	
	// 限制最多同时执行2个任务
	results, errors := Hunch.All(
		ctx,
		Hunch.WithConcurrency(2),
		func(ctx context.Context) (interface{}, error) {
			time.Sleep(2 * time.Second)
			return "Task 1", nil
		},
		func(ctx context.Context) (interface{}, error) {
			time.Sleep(1 * time.Second)
			return "Task 2", nil
		},
		func(ctx context.Context) (interface{}, error) {
			time.Sleep(3 * time.Second)
			return "Task 3", nil
		},
	)

	fmt.Println(results)
	fmt.Println(errors)
}

2. 重试机制

package main

import (
	"context"
	"fmt"
	"time"

	"github.com/AaronJan/Hunch"
)

func main() {
	ctx := context.Background()
	
	// 重试3次，每次间隔1秒
	result, err := Hunch.Retry(
		ctx,
		3,
		time.Second,
		func(ctx context.Context) (interface{}, error) {
			fmt.Println("Attempting task...")
			return nil, fmt.Errorf("temporary error")
		},
	)

	if err != nil {
		fmt.Println("All attempts failed:", err)
	} else {
		fmt.Println("Success:", result)
	}
}

总结

Hunch库提供了以下几种核心功能：

1. All() - 并行执行所有任务
2. Waterfall() - 顺序执行任务，前一个任务的输出是后一个任务的输入
3. Race() - 执行所有任务，返回第一个完成的任务结果
4. Retry() - 重试机制
5. 链式调用API

相比原生Golang的goroutine和channel，Hunch提供了更高层次的抽象，使得异步流程控制代码更简洁、更易读。特别适合需要复杂异步控制的场景，如微服务调用、并发数据处理等。

Hunch的API设计借鉴了JavaScript Promise的风格，对于有前端经验的开发者来说学习曲线较为平缓。同时它完全基于Golang的context包实现，可以很好地与现有的Golang生态系统集成。