Add Wait method to goPool and update usage in README and tests

- Add a new Wait method to the goPool struct to allow waiting for all tasks to finish before releasing resources.
- Update the README to reflect the new usage of the Wait method before calling the Release method.
- Update all test cases to use the new Wait method before calling the Release method.
- Update the go get command in the README to fetch a specific version of the library.

Signed-off-by: Daniel Hu <[email protected]>

Author: daniel-hutao

README.md

@@ -31,7 +31,7 @@ GoPool is a high-performance, feature-rich, and easy-to-use worker pool library
 To install GoPool, use `go get`:
 
 ```bash
-go get -u github.com/devchat-ai/gopool
+go get github.com/devchat-ai/gopool@v0.2.0
 ```
 
 ## Usage
@@ -50,12 +50,14 @@ import (
 
 func main() {
     pool := gopool.NewGoPool(100)
+    defer pool.Release()
+
     for i := 0; i < 1000; i++ {
         pool.AddTask(func() {
             time.Sleep(10 * time.Millisecond)
         })
     }
-    pool.Release()
+    pool.Wait()
 }
 ```
 
@@ -73,12 +75,14 @@ import (
 
 func main() {
     pool := gopool.NewGoPool(100, gopool.WithLock(new(spinlock.SpinLock)))
+    defer pool.Release()
+
     for i := 0; i < 1000; i++ {
         pool.AddTask(func() {
             time.Sleep(10 * time.Millisecond)
         })
     }
-    pool.Release()
+    pool.Wait()
 }
 ```
 
@@ -99,12 +103,14 @@ import (
 
 func main() {
     pool := gopool.NewGoPool(100, gopool.WithMinWorkers(50))
+    defer pool.Release()
+
     for i := 0; i < 1000; i++ {
         pool.AddTask(func() {
             time.Sleep(10 * time.Millisecond)
         })
     }
-    pool.Release()
+    pool.Wait()
 }
 ```
 
@@ -127,13 +133,15 @@ import (
 
 func main() {
     pool := gopool.NewGoPool(100, gopool.WithTimeout(1*time.Second))
+    defer pool.Release()
+
     for i := 0; i < 1000; i++ {
         pool.AddTask(func() (interface{}, error) {
             time.Sleep(2 * time.Second)
             return nil, nil
         })
     }
-    pool.Release()
+    pool.Wait()
 }
 ```
 
@@ -159,12 +167,14 @@ func main() {
     pool := gopool.NewGoPool(100, gopool.WithErrorCallback(func(err error) {
         fmt.Println("Task error:", err)
     }))
+    defer pool.Release()
+
     for i := 0; i < 1000; i++ {
         pool.AddTask(func() (interface{}, error) {
             return nil, errors.New("task error")
         })
     }
-    pool.Release()
+    pool.Wait()
 }
 ```
 
@@ -189,12 +199,14 @@ func main() {
     pool := gopool.NewGoPool(100, gopool.WithResultCallback(func(result interface{}) {
         fmt.Println("Task result:", result)
     }))
+    defer pool.Release()
+
     for i := 0; i < 1000; i++ {
         pool.AddTask(func() (interface{}, error) {
             return "task result", nil
         })
     }
-    pool.Release()
+    pool.Wait()
 }
 ```
 

gopool.go

@@ -70,6 +70,13 @@ func (p *goPool) AddTask(t task) {
     p.taskQueue <- t
 }
 
+// Wait waits for all tasks to be dispatched.
+func (p *goPool) Wait() {
+    for len(p.taskQueue) > 0 {
+        time.Sleep(100 * time.Millisecond)
+    }
+}
+
 // Release stops all workers and releases resources.
 func (p *goPool) Release() { 
     close(p.taskQueue)

gopool_test.go

@@ -11,30 +11,33 @@ import (
 
 func TestGoPoolWithMutex(t *testing.T) {
 	pool := NewGoPool(100, WithLock(new(sync.Mutex)))
+	defer pool.Release()
 	for i := 0; i < 1000; i++ {
 		pool.AddTask(func() (interface{}, error) {
 			time.Sleep(10 * time.Millisecond)
 			return nil, nil
 		})
 	}
-	pool.Release()
+	pool.Wait()
 }
 
 func TestGoPoolWithSpinLock(t *testing.T) {
 	pool := NewGoPool(100, WithLock(new(spinlock.SpinLock)))
+	defer pool.Release()
 	for i := 0; i < 1000; i++ {
 		pool.AddTask(func() (interface{}, error) {
 			time.Sleep(10 * time.Millisecond)
 			return nil, nil
 		})
 	}
-	pool.Release()
+	pool.Wait()
 }
 
 func BenchmarkGoPoolWithMutex(b *testing.B) {
 	var wg sync.WaitGroup
 	var taskNum = int(1e6)
 	pool := NewGoPool(1e4, WithLock(new(sync.Mutex)))
+	defer pool.Release()
 
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
@@ -46,16 +49,16 @@ func BenchmarkGoPoolWithMutex(b *testing.B) {
 				return nil, nil
 			})
 		}
+		wg.Wait()
 	}
-	wg.Wait()
 	b.StopTimer()
-	pool.Release()
 }
 
 func BenchmarkGoPoolWithSpinLock(b *testing.B) {
 	var wg sync.WaitGroup
 	var taskNum = int(1e6)
 	pool := NewGoPool(1e4, WithLock(new(spinlock.SpinLock)))
+	defer pool.Release()
 
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
@@ -67,10 +70,9 @@ func BenchmarkGoPoolWithSpinLock(b *testing.B) {
 				return nil, nil
 			})
 		}
+		wg.Wait()
 	}
-	wg.Wait()
 	b.StopTimer()
-	pool.Release()
 }
 
 func BenchmarkGoroutines(b *testing.B) {
@@ -86,6 +88,7 @@ func BenchmarkGoroutines(b *testing.B) {
 				return nil, nil
 			}()
 		}
+		wg.Wait()
 	}
 }
 
@@ -96,12 +99,14 @@ func TestGoPoolWithError(t *testing.T) {
             t.Errorf("Expected error %v, but got %v", errTaskError, err)
         }
     }))
+	defer pool.Release()
+
     for i := 0; i< 1000; i++ {
         pool.AddTask(func() (interface{}, error) {
             return nil, errTaskError
         })
     }
-    pool.Release()
+    pool.Wait()
 }
 
 func TestGoPoolWithResult(t *testing.T) {
@@ -111,10 +116,12 @@ func TestGoPoolWithResult(t *testing.T) {
             t.Errorf("Expected result %v, but got %v", expectedResult, result)
         }
     }))
+	defer pool.Release()
+
     for i := 0; i< 1000; i++ {
         pool.AddTask(func() (interface{}, error) {
             return expectedResult, nil
         })
     }
-    pool.Release()
+    pool.Wait()
 }