feat: add RunCompleted method to Paralleler.

Author: ghosind

paralleler.go

@@ -3,6 +3,7 @@ package async
 import (
 	"context"
 	"sync"
+	"sync/atomic"
 )
 
 // builtinPool is the Parallelers pool for built-in functions.
@@ -76,7 +77,7 @@ func (p *Paralleler) Run() ([][]any, error) {
 
 	ch := make(chan executeResult, len(tasks))
 
-	go p.runTasks(ctx, ch, tasks)
+	go p.runTasks(ctx, ch, tasks, true)
 
 	finished := 0
 	for finished < len(tasks) {
@@ -98,6 +99,41 @@ func (p *Paralleler) Run() ([][]any, error) {
 	return out, nil
 }
 
+// RunCompleted runs the tasks in the paralleler's pending list until all functions are finished,
+// it'll clear the pending list and return the results of the tasks.
+func (p *Paralleler) RunCompleted() ([][]any, error) {
+	tasks := p.getTasks()
+	out := make([][]any, len(tasks))
+	if len(tasks) == 0 {
+		return out, nil
+	}
+
+	errs := make([]error, len(tasks))
+	errNum := atomic.Int32{}
+	parent := getContext(p.ctx)
+	ctx, canFunc := context.WithCancel(parent)
+	defer canFunc()
+
+	ch := make(chan executeResult, len(tasks))
+
+	go p.runTasks(ctx, ch, tasks, false)
+
+	for finished := 0; finished < len(tasks); finished++ {
+		ret := <-ch
+		out[ret.Index] = ret.Out
+		if ret.Error != nil {
+			errs[ret.Index] = ret.Error
+			errNum.Add(1)
+		}
+	}
+
+	if errNum.Load() == 0 {
+		return out, nil
+	}
+
+	return out, convertErrorListToExecutionErrors(errs, int(errNum.Load()))
+}
+
 // getConcurrencyChan creates and returns a concurrency controlling channel by the specific number
 // of the concurrency limitation.
 func (p *Paralleler) getConcurrencyChan() chan empty {
@@ -124,15 +160,20 @@ func (p *Paralleler) getTasks() []AsyncFn {
 }
 
 // runTasks runs the tasks with the concurrency limitation.
-func (p *Paralleler) runTasks(ctx context.Context, resCh chan executeResult, tasks []AsyncFn) {
+func (p *Paralleler) runTasks(
+	ctx context.Context,
+	resCh chan executeResult,
+	tasks []AsyncFn,
+	exitWhenDone bool,
+) {
 	conch := p.getConcurrencyChan()
 
 	for i := 0; i < len(tasks); i++ {
 		if conch != nil {
 			conch <- empty{}
 		}
 
-		go p.runTask(ctx, i, tasks[i], conch, resCh)
+		go p.runTask(ctx, i, tasks[i], conch, resCh, exitWhenDone)
 	}
 }
 
@@ -143,6 +184,7 @@ func (p *Paralleler) runTask(
 	fn AsyncFn,
 	conch chan empty,
 	ch chan executeResult,
+	exitWhenDone bool,
 ) {
 	childCtx, childCanFunc := context.WithCancel(ctx)
 	defer childCanFunc()
@@ -153,14 +195,22 @@ func (p *Paralleler) runTask(
 		<-conch
 	}
 
-	select {
-	case <-ctx.Done():
-		return
-	default:
+	if !exitWhenDone {
 		ch <- executeResult{
 			Index: n,
 			Error: err,
 			Out:   ret,
 		}
+	} else {
+		select {
+		case <-ctx.Done():
+			return
+		default:
+			ch <- executeResult{
+				Index: n,
+				Error: err,
+				Out:   ret,
+			}
+		}
 	}
 }

paralleler_test.go

@@ -2,6 +2,7 @@ package async_test
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"sync/atomic"
 	"testing"
@@ -74,7 +75,7 @@ func TestParallelerClear(t *testing.T) {
 	}
 
 	_, err := p.Run()
-	a.Nil(err)
+	a.NilNow(err)
 	a.EqualNow(cnt.Load(), 3)
 }
 
@@ -125,6 +126,29 @@ func TestParallelerWithContext(t *testing.T) {
 	a.EqualNow(cnt.Load(), 2)
 }
 
+func TestParallelerRunCompleted(t *testing.T) {
+	a := assert.New(t)
+	cnt := atomic.Int32{}
+	expectedErr := errors.New("n = 2")
+
+	p := new(async.Paralleler).WithConcurrency(2)
+	for i := 0; i < 5; i++ {
+		n := i
+		p.Add(func() error {
+			cnt.Add(1)
+			if n == 2 {
+				return expectedErr
+			}
+			return nil
+		})
+	}
+
+	out, err := p.RunCompleted()
+	a.NotNilNow(err)
+	a.EqualNow(out, [][]any{{nil}, {nil}, {expectedErr}, {nil}, {nil}})
+	a.EqualNow(cnt.Load(), 5)
+}
+
 func ExampleParalleler() {
 	p := new(async.Paralleler)