patch: v2.12.1 (#398)

* chore: use my referral link of DO

* docs: correct WithNonblocking comment about its returned error (#390)

* fix: make Reboot() wait for pool to fully release before resetting state (#395)

* fix: resolve data race on poolCommon.once field using atomic.Pointer

The data race occurred between Reboot() writing p.once = &sync.Once{}
and worker goroutines reading p.once.Do(...) concurrently.

Fix: change the once field from *sync.Once to atomic.Pointer[sync.Once]
so all reads (Load) and writes (Store) are atomic.

Agent-Logs-Url: https://github.com/panjf2000/ants/sessions/b2f67c6c-ed78-4758-9185-643b3e09d143

Co-authored-by: panjf2000 <7496278+panjf2000@users.noreply.github.com>

* fix: make Reboot() wait for all workers to exit before resetting pool

The root cause of the data race is that Reboot() resets pool state
(once, allDone) while workers are still shutting down and accessing
those same fields.

Fix: Reboot() now waits on the allDone channel (which is closed when
the last worker exits) before resetting pool state. This ensures no
worker goroutine is running when the fields are reassigned, eliminating
the data race without needing atomic wrappers.

Reverts the atomic.Pointer[sync.Once] approach in favor of this
fundamental fix.

Agent-Logs-Url: https://github.com/panjf2000/ants/sessions/7b1d6e25-546a-40ef-b31d-33e824186b31

Co-authored-by: panjf2000 <7496278+panjf2000@users.noreply.github.com>

* fix: also wait for purge/ticktock goroutines to exit in Reboot()

Ensures the old purge and ticktock goroutines have fully exited
(set their done flags) before Reboot() resets those flags and
starts new goroutines. This prevents a logic race where the old
goroutine could set purgeDone/ticktockDone=1 after Reboot() resets
them to 0.

Agent-Logs-Url: https://github.com/panjf2000/ants/sessions/480234c8-a50f-4dc3-9352-0b337ebfc5d3

Co-authored-by: panjf2000 <7496278+panjf2000@users.noreply.github.com>

---------

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: panjf2000 <7496278+panjf2000@users.noreply.github.com>

* chore: improve variable naming in binarySearch (#393)

* fix: release created pools on NewMultiPool failure (#394)

* chore: replace 1<<31-1 with math.MaxInt32 (#392)

* fix: move once.Do(close(allDone)) from Reboot() to Release() (#397)

* fix: use atomic.Pointer for once field to prevent data race in Reboot

The data race occurred between Reboot() writing p.once = &sync.Once{}
and worker goroutines reading p.once to call once.Do(close(allDone)).

By using atomic.Pointer[sync.Once], all reads (Load) and writes (Store)
to the once field are properly synchronized.

Agent-Logs-Url: https://github.com/panjf2000/ants/sessions/4a1d1b13-0a7f-4167-ae12-429e7719ea32

Co-authored-by: panjf2000 <7496278+panjf2000@users.noreply.github.com>

* fix: use sync.WaitGroup to ensure all worker goroutines fully exit before Reboot

Revert the superficial atomic.Pointer fix. The real issue is that
Reboot() proceeded after allDone (running count hit 0) while worker
goroutines were still executing deferred cleanup code.

Add workerWg sync.WaitGroup to poolCommon. Each worker goroutine calls
wg.Add(1) before spawning and defer wg.Done() as the outermost defer
(runs last). Reboot() calls workerWg.Wait() after <-allDone to block
until every goroutine has fully exited before resetting pool state.

Agent-Logs-Url: https://github.com/panjf2000/ants/sessions/758f404a-fab6-4a4e-8f42-ea4fdfd2ab9a

Co-authored-by: panjf2000 <7496278+panjf2000@users.noreply.github.com>

* fix: call workerWg.Add(1) before addRunning(1) for defensive ordering

Agent-Logs-Url: https://github.com/panjf2000/ants/sessions/758f404a-fab6-4a4e-8f42-ea4fdfd2ab9a

Co-authored-by: panjf2000 <7496278+panjf2000@users.noreply.github.com>

* fix: move once.Do(close(allDone)) to Release() instead of Reboot()

This is the fundamental fix: Release() is the proper place to close
allDone when no workers are running, since it's the operation that
transitions the pool to CLOSED state. If workers are still running,
the last one to exit closes allDone in its defer as before.

This eliminates the race between Reboot() and running workers on
once.Do, and removes the unnecessary workerWg complexity.

Agent-Logs-Url: https://github.com/panjf2000/ants/sessions/0d78b737-d4ef-4dbd-b021-3e532757c1f9

Co-authored-by: panjf2000 <7496278+panjf2000@users.noreply.github.com>

---------

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: panjf2000 <7496278+panjf2000@users.noreply.github.com>

---------

Co-authored-by: hehaifeng526 <54569318+vibe-sudo@users.noreply.github.com>
Co-authored-by: Copilot <198982749+Copilot@users.noreply.github.com>
Co-authored-by: panjf2000 <7496278+panjf2000@users.noreply.github.com>

Author: 3 people

README.md

@@ -347,8 +347,4 @@ If you have `ants` integrated into projects, feel free to open a pull request re
 
 ## 🔋 Sponsorship
 
-<p>
-  <a href="https://www.digitalocean.com/">
-    <img src="https://opensource.nyc3.cdn.digitaloceanspaces.com/attribution/assets/PoweredByDO/DO_Powered_by_Badge_blue.svg" width="201px">
-  </a>
-</p>
+[![DigitalOcean Referral Badge](https://web-platforms.sfo2.cdn.digitaloceanspaces.com/WWW/Badge%203.svg)](https://www.digitalocean.com/?refcode=5d8774f42124&utm_campaign=Referral_Invite&utm_medium=Referral_Program&utm_source=badge)

README_ZH.md

@@ -346,8 +346,4 @@ pool.Reboot()
 
 ## 🔋 赞助商
 
-<p>
-  <a href="https://www.digitalocean.com/">
-    <img src="https://opensource.nyc3.cdn.digitaloceanspaces.com/attribution/assets/PoweredByDO/DO_Powered_by_Badge_blue.svg" width="201px">
-  </a>
-</p>
+[![DigitalOcean Referral Badge](https://web-platforms.sfo2.cdn.digitaloceanspaces.com/WWW/Badge%203.svg)](https://www.digitalocean.com/?refcode=5d8774f42124&utm_campaign=Referral_Invite&utm_medium=Referral_Program&utm_source=badge)

ants.go

@@ -402,6 +402,15 @@ func (p *poolCommon) Release() {
 	// There might be some callers waiting in retrieveWorker(), so we need to wake them up to prevent
 	// those callers blocking infinitely.
 	p.cond.Broadcast()
+
+	// If there are no running workers at the time of Release, close allDone immediately
+	// so that Reboot() or ReleaseContext() won't block on <-p.allDone indefinitely.
+	// If workers are still running, the last one to exit will close allDone in its defer.
+	if p.Running() == 0 {
+		p.once.Do(func() {
+			close(p.allDone)
+		})
+	}
 }
 
 // ReleaseTimeout is like Release but with a timeout, it waits all workers to exit before timing out.
@@ -438,12 +447,6 @@ func (p *poolCommon) ReleaseContext(ctx context.Context) error {
 		purgeCh = p.allDone
 	}
 
-	if p.Running() == 0 {
-		p.once.Do(func() {
-			close(p.allDone)
-		})
-	}
-
 	for {
 		select {
 		case <-ctx.Done():
@@ -465,14 +468,36 @@ func (p *poolCommon) ReleaseContext(ctx context.Context) error {
 // Release() to ensure that all workers are stopped and resource are released
 // before rebooting, otherwise you may run into data race.
 func (p *poolCommon) Reboot() {
-	if atomic.CompareAndSwapInt32(&p.state, CLOSED, OPENED) {
-		atomic.StoreInt32(&p.purgeDone, 0)
-		p.goPurge()
-		atomic.StoreInt32(&p.ticktockDone, 0)
-		p.goTicktock()
-		p.allDone = make(chan struct{})
-		p.once = &sync.Once{}
+	if atomic.LoadInt32(&p.state) != CLOSED {
+		return
 	}
+
+	// Wait for all workers to exit. The allDone channel is closed either
+	// by Release() (if no workers were running) or by the last exiting worker.
+	<-p.allDone
+
+	// Wait for the purge and ticktock goroutines to exit completely,
+	// so that their deferred purgeDone/ticktockDone stores don't
+	// race with the resets below.
+	if !p.options.DisablePurge {
+		for atomic.LoadInt32(&p.purgeDone) != 1 {
+			runtime.Gosched()
+		}
+	}
+	for atomic.LoadInt32(&p.ticktockDone) != 1 {
+		runtime.Gosched()
+	}
+
+	if !atomic.CompareAndSwapInt32(&p.state, CLOSED, OPENED) {
+		return
+	}
+
+	atomic.StoreInt32(&p.purgeDone, 0)
+	p.goPurge()
+	atomic.StoreInt32(&p.ticktockDone, 0)
+	p.goTicktock()
+	p.allDone = make(chan struct{})
+	p.once = &sync.Once{}
 }
 
 func (p *poolCommon) addRunning(delta int) int {

multipool.go

@@ -108,6 +108,10 @@ func NewMultiPool(size, sizePerPool int, lbs LoadBalancingStrategy, options ...O
 	for i := 0; i < size; i++ {
 		pool, err := NewPool(sizePerPool, options...)
 		if err != nil {
+			// Release all previously created pools to avoid resource leak
+			for j := 0; j < i; j++ {
+				pools[j].Release()
+			}
 			return nil, err
 		}
 		pools[i] = pool
@@ -120,7 +124,7 @@ func (mp *MultiPool) next(lbs LoadBalancingStrategy) (idx int) {
 	case RoundRobin:
 		return int(atomic.AddUint32(&mp.index, 1) % uint32(len(mp.pools)))
 	case LeastTasks:
-		leastTasks := 1<<31 - 1
+		leastTasks := math.MaxInt32
 		for i, pool := range mp.pools {
 			if n := pool.Running(); n < leastTasks {
 				leastTasks = n

multipool_func.go

@@ -55,6 +55,10 @@ func NewMultiPoolWithFunc(size, sizePerPool int, fn func(any), lbs LoadBalancing
 	for i := 0; i < size; i++ {
 		pool, err := NewPoolWithFunc(sizePerPool, fn, options...)
 		if err != nil {
+			// Release all previously created pools to avoid resource leak
+			for j := 0; j < i; j++ {
+				pools[j].Release()
+			}
 			return nil, err
 		}
 		pools[i] = pool
@@ -67,7 +71,7 @@ func (mp *MultiPoolWithFunc) next(lbs LoadBalancingStrategy) (idx int) {
 	case RoundRobin:
 		return int(atomic.AddUint32(&mp.index, 1) % uint32(len(mp.pools)))
 	case LeastTasks:
-		leastTasks := 1<<31 - 1
+		leastTasks := math.MaxInt32
 		for i, pool := range mp.pools {
 			if n := pool.Running(); n < leastTasks {
 				leastTasks = n

multipool_func_generic.go

@@ -51,6 +51,10 @@ func NewMultiPoolWithFuncGeneric[T any](size, sizePerPool int, fn func(T), lbs L
 	for i := 0; i < size; i++ {
 		pool, err := NewPoolWithFuncGeneric(sizePerPool, fn, options...)
 		if err != nil {
+			// Release all previously created pools to avoid resource leak
+			for j := 0; j < i; j++ {
+				pools[j].Release()
+			}
 			return nil, err
 		}
 		pools[i] = pool
@@ -63,7 +67,7 @@ func (mp *MultiPoolWithFuncGeneric[T]) next(lbs LoadBalancingStrategy) (idx int)
 	case RoundRobin:
 		return int(atomic.AddUint32(&mp.index, 1) % uint32(len(mp.pools)))
 	case LeastTasks:
-		leastTasks := 1<<31 - 1
+		leastTasks := math.MaxInt32
 		for i, pool := range mp.pools {
 			if n := pool.Running(); n < leastTasks {
 				leastTasks = n

options.go

@@ -96,7 +96,7 @@ func WithMaxBlockingTasks(maxBlockingTasks int) Option {
 	}
 }
 
-// WithNonblocking indicates that pool will return nil when there is no available workers.
+// WithNonblocking indicates that pool will return ErrPoolOverload when there is no available workers.
 func WithNonblocking(nonblocking bool) Option {
 	return func(opts *Options) {
 		opts.Nonblocking = nonblocking

worker_loop_queue.go

@@ -124,8 +124,7 @@ func (wq *loopQueue) refresh(duration time.Duration) []worker {
 }
 
 func (wq *loopQueue) binarySearch(expiryTime int64) int {
-	var mid, nlen, basel, tmid int
-	nlen = len(wq.items)
+	n := len(wq.items)
 
 	// if no need to remove work, return -1
 	if wq.isEmpty() || expiryTime < wq.items[wq.head].lastUsedTime() {
@@ -143,21 +142,21 @@ func (wq *loopQueue) binarySearch(expiryTime int64) int {
 
 	// base algorithm is a copy from worker_stack
 	// map head and tail to effective left and right
-	r := (wq.tail - 1 - wq.head + nlen) % nlen
-	basel = wq.head
+	r := (wq.tail - 1 - wq.head + n) % n
+	base := wq.head
 	l := 0
 	for l <= r {
-		mid = l + ((r - l) >> 1) // avoid overflow when computing mid
+		mid := l + ((r - l) >> 1) // avoid overflow when computing mid
 		// calculate true mid position from mapped mid position
-		tmid = (mid + basel + nlen) % nlen
+		tmid := (mid + base + n) % n
 		if expiryTime < wq.items[tmid].lastUsedTime() {
 			r = mid - 1
 		} else {
 			l = mid + 1
 		}
 	}
 	// return true position from mapped position
-	return (r + basel + nlen) % nlen
+	return (r + base + n) % n
 }
 
 func (wq *loopQueue) reset() {