Gollback: Go异步闭包与回调管理工具库详解

Gollback是一个轻量级的Go语言库，专门用于管理异步闭包和回调操作。它提供了一种简洁的方式来处理并发任务、超时控制和错误处理。

核心功能

1. 异步执行闭包函数
2. 超时控制
3. 错误处理
4. 结果收集

安装

go get github.com/vardius/gollback

基本使用示例

1. 简单异步执行

package main

import (
	"context"
	"fmt"
	"time"

	"github.com/vardius/gollback"
)

func main() {
	ctx := context.Background()

	// 异步执行单个闭包
	res, err := gollback.Race(ctx, func(ctx context.Context) (interface{}, error) {
		time.Sleep(100 * time.Millisecond)
		return "result from async function", nil
	})

	if err != nil {
		fmt.Println("Error:", err)
		return
	}

	fmt.Println("Result:", res)
}

2. 超时控制

func withTimeoutExample() {
	ctx, cancel := context.WithTimeout(context.Background(), 50*time.Millisecond)
	defer cancel()

	res, err := gollback.Race(ctx, func(ctx context.Context) (interface{}, error) {
		time.Sleep(100 * time.Millisecond) // 这个会超时
		return "this won't be returned", nil
	})

	if err != nil {
		fmt.Println("Error:", err) // 会输出context deadline exceeded
		return
	}

	fmt.Println("Result:", res)
}

3. 并行执行多个任务

func parallelExecution() {
	ctx := context.Background()

	results, err := gollback.All(
		ctx,
		gollback.Async(func(ctx context.Context) (interface{}, error) {
			time.Sleep(100 * time.Millisecond)
			return 1, nil
		}),
		gollback.Async(func(ctx context.Context) (interface{}, error) {
			time.Sleep(200 * time.Millisecond)
			return 2, nil
		}),
		gollback.Async(func(ctx context.Context) (interface{}, error) {
			time.Sleep(50 * time.Millisecond)
			return 3, nil
		}),
	)

	if err != nil {
		fmt.Println("Error:", err)
		return
	}

	fmt.Println("Results:", results) // 输出: [1 2 3]
}

4. 竞速执行（第一个完成的任务返回）

func raceExample() {
	ctx := context.Background()

	res, err := gollback.Race(
		ctx,
		gollback.Async(func(ctx context.Context) (interface{}, error) {
			time.Sleep(200 * time.Millisecond)
			return "slow", nil
		}),
		gollback.Async(func(ctx context.Context) (interface{}, error) {
			time.Sleep(100 * time.Millisecond)
			return "fast", nil
		}),
	)

	if err != nil {
		fmt.Println("Error:", err)
		return
	}

	fmt.Println("Winner:", res) // 输出: fast
}

5. 重试机制

func retryExample() {
	ctx := context.Background()
	
	retryCount := 3
	var attempt int

	res, err := gollback.Retry(ctx, retryCount, func(ctx context.Context) (interface{}, error) {
		attempt++
		if attempt < retryCount {
			return nil, fmt.Errorf("attempt %d failed", attempt)
		}
		return "success on attempt " + strconv.Itoa(attempt), nil
	})

	if err != nil {
		fmt.Println("Final error:", err)
		return
	}

	fmt.Println("Result:", res) // 输出: success on attempt 3
}

高级用法

自定义超时和取消

func advancedTimeout() {
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	// 在另一个goroutine中取消操作
	go func() {
		time.Sleep(50 * time.Millisecond)
		cancel()
	}()

	res, err := gollback.Race(ctx, func(ctx context.Context) (interface{}, error) {
		select {
		case <-time.After(100 * time.Millisecond):
			return "completed", nil
		case <-ctx.Done():
			return nil, ctx.Err()
		}
	})

	if err != nil {
		fmt.Println("Operation canceled:", err)
		return
	}

	fmt.Println("Result:", res)
}

组合使用

func combinedExample() {
	ctx := context.Background()

	// 并行执行3个任务，每个任务有重试机制
	results, err := gollback.All(
		ctx,
		gollback.AsyncWithRetry(2, func(ctx context.Context) (interface{}, error) {
			// 模拟有时失败的任务
			if time.Now().UnixNano()%2 == 0 {
				return nil, fmt.Errorf("random error")
			}
			return "task1", nil
		}),
		gollback.Async(func(ctx context.Context) (interface{}, error) {
			return "task2", nil
		}),
		gollback.AsyncWithRetry(1, func(ctx context.Context) (interface{}, error) {
			return "task3", nil
		}),
	)

	if err != nil {
		fmt.Println("Error:", err)
		return
	}

	fmt.Println("All results:", results)
}

最佳实践

1. 始终传递context：确保能够控制goroutine的生命周期
2. 合理设置超时：避免goroutine泄漏
3. 错误处理：检查所有返回的错误
4. 资源清理：使用defer或context取消来释放资源
5. 限制并发：对于大量任务，考虑使用worker pool模式

Gollback是一个简单但功能强大的库，特别适合需要管理多个异步操作的场景。它的API设计简洁，与Go的标准库（特别是context包）良好集成，是处理并发回调的优秀工具。