Golang 安全异步执行函数并自动恢复 panic 的 async 库使用指南

在 Go 语言中，处理异步任务并确保 panic 被安全捕获是一个常见需求。下面我将介绍如何使用 async 库来实现这一功能。

安装 async 库

首先安装 async 库：

go get github.com/reugn/async

基本使用方法

1. 简单的异步执行

package main

import (
	"fmt"
	"time"

	"github.com/reugn/async"
)

func main() {
	future := async.Execute(func() (interface{}, error) {
		time.Sleep(1 * time.Second)
		return "Hello, async world!", nil
	})

	// 阻塞等待结果
	result, err := future.Get()
	if err != nil {
		fmt.Println("Error:", err)
		return
	}
	fmt.Println(result) // 输出: Hello, async world!
}

2. 自动恢复 panic

package main

import (
	"fmt"
	"time"

	"github.com/reugn/async"
)

func main() {
	future := async.Execute(func() (interface{}, error) {
		time.Sleep(500 * time.Millisecond)
		panic("something went wrong") // 这里会触发 panic
		return "This won't be reached", nil
	})

	// 获取结果会自动恢复 panic 并返回错误
	result, err := future.Get()
	if err != nil {
		fmt.Println("Caught error:", err) // 输出: Caught error: something went wrong
		return
	}
	fmt.Println(result)
}

高级功能

1. 带超时的异步执行

package main

import (
	"fmt"
	"time"

	"github.com/reugn/async"
)

func main() {
	future := async.Execute(func() (interface{}, error) {
		time.Sleep(2 * time.Second)
		return "Done", nil
	})

	// 设置超时时间为1秒
	result, err := future.GetWithTimeout(1 * time.Second)
	if err != nil {
		if err == async.ErrTimeout {
			fmt.Println("Operation timed out")
		} else {
			fmt.Println("Error:", err)
		}
		return
	}
	fmt.Println(result)
}

2. 回调函数

package main

import (
	"fmt"
	"time"

	"github.com/reugn/async"
)

func main() {
	future := async.Execute(func() (interface{}, error) {
		time.Sleep(1 * time.Second)
		return 42, nil
	})

	// 添加成功回调
	future.OnSuccess(func(result interface{}) {
		fmt.Println("Success:", result) // 输出: Success: 42
	})

	// 添加失败回调
	future.OnFailure(func(err error) {
		fmt.Println("Failure:", err)
	})

	// 阻塞主线程等待结果
	_, _ = future.Get()
}

3. 组合多个异步任务

package main

import (
	"fmt"
	"time"

	"github.com/reugn/async"
)

func main() {
	future1 := async.Execute(func() (interface{}, error) {
		time.Sleep(1 * time.Second)
		return 10, nil
	})

	future2 := async.Execute(func() (interface{}, error) {
		time.Sleep(2 * time.Second)
		return 20, nil
	})

	// 等待所有任务完成
	results, errs := async.AwaitAll(future1, future2)
	if len(errs) > 0 {
		fmt.Println("Errors:", errs)
		return
	}
	fmt.Println("Results:", results) // 输出: Results: [10 20]
}

自定义配置

package main

import (
	"fmt"
	"time"

	"github.com/reugn/async"
)

func main() {
	// 创建自定义配置的异步执行器
	executor := async.NewExecutor(async.Config{
		Timeout:       3 * time.Second,  // 默认超时
		PanicHandler: func(r interface{}) {
			fmt.Printf("Custom panic handler: %v\n", r)
		},
	})

	future := executor.Execute(func() (interface{}, error) {
		time.Sleep(2 * time.Second)
		panic("custom panic")
		return nil, nil
	})

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

最佳实践

1. 合理设置超时：避免异步任务无限期阻塞
2. 使用回调：非阻塞地处理异步结果
3. 错误处理：总是检查返回的错误
4. 资源清理：长时间运行的任务应考虑上下文取消

async 库提供了一种简单而强大的方式来处理 Go 中的异步任务，同时内置了 panic 恢复机制，使得异步编程更加安全和方便。