Use new go loop feature

.github/workflows/go.yml

@@ -2,7 +2,6 @@ name: Go
 
 on:
   push:
-    branches: [ main ]
   pull_request:
     branches: [ main ]
 

.github/workflows/golangci-lint.yml

@@ -5,8 +5,7 @@ on:
     tags:
       - v*
     branches:
-      - master
-      - main
+      - "**"
   pull_request:
 
 jobs:

README.md

@@ -35,7 +35,6 @@ func main() {
 	requests := []string{"alpha", "beta", "gamma", "delta", "epsilon"}
 
 	for _, r := range requests {
-		r := r
 		wp.Submit(func() {
 			fmt.Println("Handling request:", r)
 		})

pacer/pacer_test.go

@@ -37,7 +37,7 @@ func TestPacedWorkers(t *testing.T) {
 	})
 
 	// Cause worker to be created, and available for reuse before next task.
-	for i := 0; i < 10; i++ {
+	for range 10 {
 		wp.Submit(pacedTask)
 		wp.Submit(slowPacedTask)
 	}

workerpool.go

@@ -51,7 +51,7 @@ type WorkerPool struct {
 	stopLock     sync.Mutex
 	stopOnce     sync.Once
 	stopped      bool
-	waiting      int32
+	waiting_old  atomic.Int32
 	wait         bool
 }
 
@@ -125,7 +125,7 @@ func (p *WorkerPool) SubmitWait(task func()) {
 
 // WaitingQueueSize returns the count of tasks in the waiting queue.
 func (p *WorkerPool) WaitingQueueSize() int {
-	return int(atomic.LoadInt32(&p.waiting))
+	return int(p.waiting_old.Load())
 }
 
 // Pause causes all workers to wait on the given Context, thereby making them
@@ -148,7 +148,7 @@ func (p *WorkerPool) Pause(ctx context.Context) {
 	}
 	ready := new(sync.WaitGroup)
 	ready.Add(p.maxWorkers)
-	for i := 0; i < p.maxWorkers; i++ {
+	for range p.maxWorkers {
 		p.Submit(func() {
 			ready.Done()
 			select {
@@ -199,7 +199,8 @@ Loop:
 				} else {
 					// Enqueue task to be executed by next available worker.
 					p.waitingQueue.PushBack(task)
-					atomic.StoreInt32(&p.waiting, int32(p.waitingQueue.Len()))
+					p.waitingQueue.Len()
+					p.waiting_old.Store(int32(p.waitingQueue.Len()))
 				}
 			}
 			idle = false
@@ -275,7 +276,7 @@ func (p *WorkerPool) processWaitingQueue() bool {
 		// A worker was ready, so gave task to worker.
 		p.waitingQueue.PopFront()
 	}
-	atomic.StoreInt32(&p.waiting, int32(p.waitingQueue.Len()))
+	p.waiting_old.Store(int32(p.waitingQueue.Len()))
 	return true
 }
 
@@ -296,6 +297,6 @@ func (p *WorkerPool) runQueuedTasks() {
 	for p.waitingQueue.Len() != 0 {
 		// A worker is ready, so give task to worker.
 		p.workerQueue <- p.waitingQueue.PopFront()
-		atomic.StoreInt32(&p.waiting, int32(p.waitingQueue.Len()))
+		p.waiting_old.Store(int32(p.waitingQueue.Len()))
 	}
 }

workerpool_test.go

@@ -19,7 +19,6 @@ func TestExample(t *testing.T) {
 
 	rspChan := make(chan string, len(requests))
 	for _, r := range requests {
-		r := r
 		wp.Submit(func() {
 			rspChan <- r
 		})
@@ -62,7 +61,7 @@ func TestMaxWorkers(t *testing.T) {
 	release := make(chan struct{})
 
 	// Start workers, and have them all wait on a channel before completing.
-	for i := 0; i < max; i++ {
+	for range max {
 		wp.Submit(func() {
 			started <- struct{}{}
 			<-release
@@ -96,7 +95,7 @@ func TestReuseWorkers(t *testing.T) {
 	release := make(chan struct{})
 
 	// Cause worker to be created, and available for reuse before next task.
-	for i := 0; i < 10; i++ {
+	for range 10 {
 		wp.Submit(func() { <-release })
 		release <- struct{}{}
 		time.Sleep(time.Millisecond)
@@ -178,7 +177,7 @@ func TestStop(t *testing.T) {
 
 	release := make(chan struct{})
 	finished := make(chan struct{}, max)
-	for i := 0; i < max; i++ {
+	for range max {
 		wp.Submit(func() {
 			<-release
 			finished <- struct{}{}
@@ -216,7 +215,7 @@ func TestStopWait(t *testing.T) {
 	wp := New(5)
 	release := make(chan struct{})
 	finished := make(chan struct{}, max)
-	for i := 0; i < max; i++ {
+	for range max {
 		wp.Submit(func() {
 			<-release
 			finished <- struct{}{}
@@ -229,7 +228,7 @@ func TestStopWait(t *testing.T) {
 		close(release)
 	}()
 	wp.StopWait()
-	for count := 0; count < max; count++ {
+	for range max {
 		select {
 		case <-finished:
 		default:
@@ -298,7 +297,7 @@ func TestOverflow(t *testing.T) {
 	releaseChan := make(chan struct{})
 
 	// Start workers, and have them all wait on a channel before completing.
-	for i := 0; i < 64; i++ {
+	for range 64 {
 		wp.Submit(func() { <-releaseChan })
 	}
 
@@ -331,7 +330,7 @@ func TestStopRace(t *testing.T) {
 	started.Add(max)
 
 	// Start workers, and have them all wait on a channel before completing.
-	for i := 0; i < max; i++ {
+	for range max {
 		wp.Submit(func() {
 			started.Done()
 			<-workRelChan
@@ -342,7 +341,7 @@ func TestStopRace(t *testing.T) {
 
 	const doneCallers = 5
 	stopDone := make(chan struct{}, doneCallers)
-	for i := 0; i < doneCallers; i++ {
+	for range doneCallers {
 		go func() {
 			wp.Stop()
 			stopDone <- struct{}{}
@@ -358,7 +357,7 @@ func TestStopRace(t *testing.T) {
 	close(workRelChan)
 
 	timeout := time.After(time.Second)
-	for i := 0; i < doneCallers; i++ {
+	for range doneCallers {
 		select {
 		case <-stopDone:
 		case <-timeout:
@@ -381,12 +380,12 @@ func TestWaitingQueueSizeRace(t *testing.T) {
 	defer wp.Stop()
 
 	maxChan := make(chan int)
-	for g := 0; g < goroutines; g++ {
+	for range goroutines {
 		go func() {
 			max := 0
 			// Submit 100 tasks, checking waiting queue size each time.  Report
 			// the maximum queue size seen.
-			for i := 0; i < tasks; i++ {
+			for range tasks {
 				wp.Submit(func() {
 					time.Sleep(time.Microsecond)
 				})
@@ -401,7 +400,7 @@ func TestWaitingQueueSizeRace(t *testing.T) {
 
 	// Find maximum queuesize seen by any goroutine.
 	maxMax := 0
-	for g := 0; g < goroutines; g++ {
+	for range goroutines {
 		max := <-maxChan
 		if max > maxMax {
 			maxMax = max
@@ -587,7 +586,7 @@ func TestWorkerLeak(t *testing.T) {
 	wp := New(workerCount)
 
 	// Start workers, and have them all wait on a channel before completing.
-	for i := 0; i < workerCount; i++ {
+	for range workerCount {
 		wp.Submit(func() {
 			time.Sleep(time.Millisecond)
 		})
@@ -647,7 +646,7 @@ func BenchmarkEnqueue(b *testing.B) {
 	b.ResetTimer()
 
 	// Start workers, and have them all wait on a channel before completing.
-	for i := 0; i < b.N; i++ {
+	for range b.N {
 		wp.Submit(func() { <-releaseChan })
 	}
 	close(releaseChan)
@@ -660,9 +659,9 @@ func BenchmarkEnqueue2(b *testing.B) {
 	b.ResetTimer()
 
 	// Start workers, and have them all wait on a channel before completing.
-	for i := 0; i < b.N; i++ {
+	for range b.N {
 		releaseChan := make(chan struct{})
-		for i := 0; i < 64; i++ {
+		for range 64 {
 			wp.Submit(func() { <-releaseChan })
 		}
 		close(releaseChan)
@@ -702,8 +701,8 @@ func benchmarkExecWorkers(n int, b *testing.B) {
 	b.ResetTimer()
 
 	// Start workers, and have them all wait on a channel before completing.
-	for i := 0; i < b.N; i++ {
-		for j := 0; j < n; j++ {
+	for range b.N {
+		for range n {
 			wp.Submit(func() {
 				//time.Sleep(100 * time.Microsecond)
 				allDone.Done()