Golang异步同步替代库async的使用

在Go语言中，虽然原生支持goroutine实现并发，但有时我们需要更高级的异步/同步控制。async库是一个流行的Go异步编程工具，提供了Promise/Future模式，让异步代码更易管理。

安装async库

go get github.com/reugn/async

基本使用示例

1. 创建Promise

package main

import (
	"fmt"
	"time"
	"github.com/reugn/async"
)

func main() {
	promise := async.NewPromise()
	
	go func() {
		time.Sleep(1 * time.Second)
		promise.Success("Operation completed!")
	}()
	
	result, err := promise.Get()
	if err != nil {
		fmt.Println("Error:", err)
		return
	}
	fmt.Println("Result:", result)
}

2. 链式调用

func chainExample() {
	async.NewPromise().
		Then(func(v interface{}) (interface{}, error) {
			fmt.Println("Step 1:", v)
			return "processed " + v.(string), nil
		}).
		Then(func(v interface{}) (interface{}, error) {
			fmt.Println("Step 2:", v)
			return len(v.(string)), nil
		}).
		OnSuccess(func(v interface{}) {
			fmt.Println("Final result:", v)
		}).
		OnFailure(func(err error) {
			fmt.Println("Error occurred:", err)
		})
}

3. 异步任务组合

func combineExample() {
	p1 := async.NewPromise()
	p2 := async.NewPromise()

	go func() {
		time.Sleep(500 * time.Millisecond)
		p1.Success("Hello")
	}()

	go func() {
		time.Sleep(1 * time.Second)
		p2.Success("World")
	}()

	// 等待所有Promise完成
	combined := async.WhenAll(p1, p2)
	result, _ := combined.Get()
	fmt.Println("Combined results:", result) // [Hello World]

	// 等待任意一个Promise完成
	first := async.WhenAny(p1, p2)
	firstResult, _ := first.Get()
	fmt.Println("First completed:", firstResult)
}

4. Future模式

func futureExample() {
	future := async.NewFuture(func() (interface{}, error) {
		time.Sleep(2 * time.Second)
		return 42, nil
	})

	fmt.Println("Waiting for future...")
	result, err := future.Get()
	if err != nil {
		fmt.Println("Error:", err)
		return
	}
	fmt.Println("Future result:", result)
}

高级功能

1. 超时控制

func withTimeout() {
	promise := async.NewPromise()
	
	go func() {
		time.Sleep(3 * time.Second)
		promise.Success("Too late!")
	}()
	
	// 设置1秒超时
	result, err := promise.GetWithTimeout(1 * time.Second)
	if err == async.ErrTimeout {
		fmt.Println("Operation timed out")
		return
	}
	fmt.Println("Result:", result)
}

2. 错误处理

func errorHandling() {
	promise := async.NewPromise()
	
	go func() {
		time.Sleep(1 * time.Second)
		promise.Failure(fmt.Errorf("something went wrong"))
	}()
	
	_, err := promise.Get()
	if err != nil {
		fmt.Println("Caught error:", err)
	}
}

3. 转换回调为Promise

func callbackToPromise() {
	// 模拟一个回调函数
	callbackFunc := func(callback func(string, error)) {
		time.Sleep(1 * time.Second)
		callback("callback result", nil)
	}
	
	// 将回调转换为Promise
	promise := async.FromCallback(func() (string, error) {
		var result string
		var err error
		done := make(chan struct{})
		
		callbackFunc(func(s string, e error) {
			result = s
			err = e
			close(done)
		})
		
		<-done
		return result, err
	})
	
	result, _ := promise.Get()
	fmt.Println("Converted result:", result)
}

实际应用场景

1. 并发API调用：同时调用多个API并合并结果
2. 超时控制：为长时间运行的操作设置超时
3. 任务流水线：创建一系列依赖的异步任务
4. 错误传播：在异步链中优雅地处理错误

注意事项

1. Promise一旦完成(成功或失败)，状态就不能再改变
2. Get()方法是阻塞的，考虑使用GetWithTimeout()
3. 大量使用Promise可能会增加代码复杂性，评估是否真的需要

async库为Go提供了更灵活的异步编程模式，特别适合需要复杂异步控制的场景。但对于简单并发，标准库的goroutine和channel可能更合适。