在 Go 中构建健壮的任务执行上下文

package taskctx

import (
    "context"
    "errors"
    "fmt"
    "sync"
)

type runfn[T any] func() (T, error)

type taskcontext struct {
    context.Context
    mu       sync.RWMutex
    err      error
    multierr []error
}

func newtaskcontext(parent context.Context) *taskcontext {
    if parent == nil {
        panic("cannot create context from nil parent")
    }
    return &taskcontext{Context: parent}
}

func (c *taskcontext) witherror(err error) *taskcontext {
    if err == nil {
        return c
    }

    c.mu.Lock()
    defer c.mu.Unlock()

    c.multierr = append(c.multierr, err)
    if c.err == nil {
        c.err = err
    } else {
        c.err = errors.Join(c.err, err)
    }
    return c
}

func run[T any](ctx *taskcontext, fn runfn[T]) T {
    var zero T
    if err := ctx.Err(); err != nil {
        return zero
    }

    result, err := fn()
    if err != nil {
        ctx.witherror(err)
        return zero
    }
    return result
}

func runparallel[T any](ctx *taskcontext, fns ...func() (T, error)) ([]T, error) {
    if err := ctx.Err(); err != nil {
        return nil, err
    }

    results := make([]T, len(fns))
    var resultsmu sync.Mutex
    var wg sync.WaitGroup
    wg.Add(len(fns))

    for i, fn := range fns {
        i, fn := i, fn
        go func() {
            defer wg.Done()
            result, err := fn()
            if err != nil {
                ctx.witherror(fmt.Errorf("task %d: %w", i+1, err))
            } else {
                resultsmu.Lock()
                results[i] = result
                resultsmu.Unlock()
            }
        }()
    }

    wg.Wait()
    return results, ctx.errors()
}

func runparallelwithlimit[T any](ctx *taskcontext, limit int, fns ...func() (T, error)) ([]T, error) {
    // ... 使用信号量实现受限并发 ...
}

// ... (测试代码略，与原文类似) ...