Golang新手求代码评审

这是一个很好的尝试，展示了Go语言中异步编程的思考。以下是对你代码的专业评审：

代码分析

优点：

1. 类型安全：使用了泛型，可以处理任意类型的返回值
2. 上下文支持：正确集成了context，支持取消操作
3. 错误处理：考虑了panic恢复和错误传播

主要问题：

1. 竞态条件：status字段存在数据竞争
2. 多次调用Await：如果多次调用Await，会启动多个goroutine
3. 内存泄漏风险：通道可能永远不会被消费

改进版本

package task

import (
	"context"
	"fmt"
	"sync"
	"sync/atomic"
)

type TaskStatus int32

const (
	New TaskStatus = iota
	Running
	Completed
)

type Task[T any] interface {
	Status() TaskStatus
	Result() (T, error)
	Await(ctx context.Context) (T, error)
}

type task[T any] struct {
	result T
	err    error
	done   chan struct{}
	status atomic.Int32
	once   sync.Once
	fn     func(ctx context.Context) (T, error)
}

func NewTask[T any](fn func(ctx context.Context) (T, error)) *task[T] {
	return &task[T]{
		done: make(chan struct{}),
		fn:   fn,
	}
}

func (t *task[T]) Status() TaskStatus {
	return TaskStatus(t.status.Load())
}

func (t *task[T]) Result() (T, error) {
	if t.Status() != Completed {
		var zero T
		return zero, fmt.Errorf("task not completed")
	}
	return t.result, t.err
}

func (t *task[T]) Await(ctx context.Context) (T, error) {
	// 确保只执行一次
	t.once.Do(func() {
		go t.execute(ctx)
	})

	select {
	case <-ctx.Done():
		var zero T
		return zero, ctx.Err()
	case <-t.done:
		return t.result, t.err
	}
}

func (t *task[T]) execute(ctx context.Context) {
	defer func() {
		if r := recover(); r != nil {
			t.err = fmt.Errorf("task panicked: %v", r)
		}
		t.status.Store(int32(Completed))
		close(t.done)
	}()

	t.status.Store(int32(Running))
	t.result, t.err = t.fn(ctx)
}

使用示例

func main() {
	// 创建任务
	task1 := NewTask(func(ctx context.Context) (int, error) {
		time.Sleep(1 * time.Second)
		return 42, nil
	})

	task2 := NewTask(func(ctx context.Context) (string, error) {
		time.Sleep(500 * time.Millisecond)
		return "hello", nil
	})

	// 并发执行
	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
	defer cancel()

	var wg sync.WaitGroup
	wg.Add(2)

	go func() {
		defer wg.Done()
		result, err := task1.Await(ctx)
		if err != nil {
			fmt.Printf("Task1 error: %v\n", err)
		} else {
			fmt.Printf("Task1 result: %d\n", result)
		}
	}()

	go func() {
		defer wg.Done()
		result, err := task2.Await(ctx)
		if err != nil {
			fmt.Printf("Task2 error: %v\n", err)
		} else {
			fmt.Printf("Task2 result: %s\n", result)
		}
	}()

	wg.Wait()
}

现有解决方案

确实有更成熟的解决方案：

1. golang.org/x/sync/errgroup - 官方并发原语

var g errgroup.Group
g.Go(func() error { return doWork1() })
g.Go(func() error { return doWork2() })
if err := g.Wait(); err != nil {
    // 处理错误
}

1. github.com/sourcegraph/conc - 更高级的并发工具

pool := conc.NewWaitGroup()
pool.Go(func() { doWork1() })
pool.Go(func() { doWork2() })
pool.Wait()

1. Future/Promise模式实现：

// 例如：github.com/chebyrash/promise
p := promise.New(func(resolve func(int), reject func(error)) {
    // 异步操作
    resolve(42)
})

result, err := p.Await()

你的实现思路是正确的，但Go社区更倾向于使用更简单、更明确的并发模式。对于生产环境，建议使用经过充分测试的现有库。