调整代码

Author: FishGoddess

FUTURE.md

@@ -2,15 +2,15 @@
 
 ### v0.2.x
 
-* [x] 增加轻量的异步执行器
+* [x] 增加异步任务执行器
 * [x] 支持轮询调度策略
 * [ ] 支持随机调度策略
 * [ ] 支持任务数量优先调度策略
 * [ ] 支持任务时间优先调度策略
 * [x] 支持设置 worker 任务队列大小
 * [x] 支持设置 panic 处理函数
 * [x] 支持自定义 sync.Locker 实现
-* [x] 完善单元测试，将覆盖率提高到 90% 以上
+* [ ] 完善单元测试，将覆盖率提高到 95% 以上
 
 ### v0.1.0
 

HISTORY.md

@@ -1,5 +1,16 @@
 ## ✒ 历史版本的特性介绍 (Features in old versions)
 
+### v0.2.0-alpha
+
+> 此版本发布于 2025-06-25
+
+* 增加异步任务执行器
+* 支持轮询调度策略
+* 支持设置 worker 任务队列大小
+* 支持设置 panic 处理函数
+* 支持自定义 sync.Locker 实现
+* 单元测试覆盖率提高到 94%
+
 ### v0.1.0
 
 > 此版本发布于 2025-06-21

README.en.md

@@ -5,14 +5,15 @@
 [![Coverage](_icons/coverage.svg)](./_icons/coverage.svg)
 ![Test](https://github.com/FishGoddess/goes/actions/workflows/test.yml/badge.svg)
 
-**Goes** is a easy-to-use and lightweight lib for limiting goroutines.
+**Goes** is a easy-to-use and lightweight lib for executing async tasks.
 
 [阅读中文版的文档](./README.md)
 
 ### 🥇 Features
 
-* Spin lock with backoff strategy.
-* Limiter only limits the number of simultaneous goroutines, not reuses goroutines.
+* Supports spin lock with backoff strategy.
+* Limits the number of simultaneous goroutines and not reuses them by Limiter.
+* Limits the number of simultaneous goroutines and reuses them by Executor.
 
 _Check [HISTORY.md](./HISTORY.md) and [FUTURE.md](./FUTURE.md) to know about more information._
 
@@ -33,16 +34,28 @@ import (
 )
 
 func main() {
+	// Limits the number of simultaneous goroutines and not reuses them.
 	limiter := goes.NewLimiter(4)
 
-	for i := 0; i < 100; i++ {
+	for i := 0; i < 20; i++ {
 		limiter.Go(func() {
-			fmt.Println(time.Now())
-			time.Sleep(100 * time.Millisecond)
+			fmt.Println("limiter --> ", time.Now())
+			time.Sleep(time.Second)
 		})
 	}
 
 	limiter.Wait()
+
+	// Limits the number of simultaneous goroutines and reuses them.
+	executor := goes.NewExecutor(4)
+	defer executor.Close()
+
+	for i := 0; i < 20; i++ {
+		executor.Submit(func() {
+			fmt.Println("executor --> ", time.Now())
+			time.Sleep(time.Second)
+		})
+	}
 }
 ```
 
@@ -60,15 +73,15 @@ goarch: amd64
 cpu: AMD EPYC 7K62 48-Core Processor
 
 BenchmarkLimiter-2               2417040               498.5 ns/op            24 B/op          1 allocs/op
-BenchmarkPool-2                 23793781                49.9 ns/op             0 B/op          0 allocs/op
+BenchmarkExecutor-2             23793781                49.9 ns/op             0 B/op          0 allocs/op
 BenchmarkAntsPool-2              4295964               271.7 ns/op             0 B/op          0 allocs/op
 
 BenchmarkLimiterTime-2:  num is 1000000, cost is 300.936441ms
-BenchmarkPoolTime-2:     num is 1000000, cost is  51.350509ms
+BenchmarkExecutorTime-2: num is 1000000, cost is  51.350509ms
 BenchmarkAntsPoolTime-2: num is  999744, cost is 346.972287ms
 ```
 
-> Obviously, goes.Pool is 5x faster than ants.Pool which has more features, so try goes if you prefer a lightweight and faster pool.
+> Obviously, goes.Executor is 5x faster than ants.Pool which has more features, so try goes if you prefer a lightweight and faster executor.
 
 > Benchmarks: [_examples/performance_test.go](./_examples/performance_test.go).
 

README.md

@@ -5,14 +5,15 @@
 [![Coverage](_icons/coverage.svg)](./_icons/coverage.svg)
 ![Test](https://github.com/FishGoddess/goes/actions/workflows/test.yml/badge.svg)
 
-**Goes** 是一个简单易用且轻量的协程数限制库。
+**Goes** 是一个简单易用且轻量的异步任务执行库。
 
 [Read me in English](./README.en.md)
 
 ### 🥇 功能特性
 
-* 支持退避策略的自旋锁。
-* Limiter 只限制同时执行的协程数，不复用协程。
+* 内置退避策略的自旋锁。
+* 支持只限制同时执行的协程数，但不复用协程，使用 Limiter。
+* 支持限制同时执行的协程数，且复用协程，使用 Executor。
 
 _历史版本的特性请查看 [HISTORY.md](./HISTORY.md)。未来版本的新特性和计划请查看 [FUTURE.md](./FUTURE.md)。_
 
@@ -33,16 +34,28 @@ import (
 )
 
 func main() {
+	// Limits the number of simultaneous goroutines and not reuses them.
 	limiter := goes.NewLimiter(4)
 
-	for i := 0; i < 100; i++ {
+	for i := 0; i < 20; i++ {
 		limiter.Go(func() {
-			fmt.Println(time.Now())
-			time.Sleep(100 * time.Millisecond)
+			fmt.Println("limiter --> ", time.Now())
+			time.Sleep(time.Second)
 		})
 	}
 
 	limiter.Wait()
+
+	// Limits the number of simultaneous goroutines and reuses them.
+	executor := goes.NewExecutor(4)
+	defer executor.Close()
+
+	for i := 0; i < 20; i++ {
+		executor.Submit(func() {
+			fmt.Println("executor --> ", time.Now())
+			time.Sleep(time.Second)
+		})
+	}
 }
 ```
 
@@ -60,15 +73,15 @@ goarch: amd64
 cpu: AMD EPYC 7K62 48-Core Processor
 
 BenchmarkLimiter-2               2417040               498.5 ns/op            24 B/op          1 allocs/op
-BenchmarkPool-2                 23793781                49.9 ns/op             0 B/op          0 allocs/op
+BenchmarkExecutor-2             23793781                49.9 ns/op             0 B/op          0 allocs/op
 BenchmarkAntsPool-2              4295964               271.7 ns/op             0 B/op          0 allocs/op
 
 BenchmarkLimiterTime-2:  num is 1000000, cost is 300.936441ms
-BenchmarkPoolTime-2:     num is 1000000, cost is  51.350509ms
+BenchmarkExecutorTime-2: num is 1000000, cost is  51.350509ms
 BenchmarkAntsPoolTime-2: num is  999744, cost is 346.972287ms
 ```
 
-> 很明显，goes.Pool 的性能比功能更丰富的 ants.Pool 要高出 5 倍左右，所以当你需要一个更轻量且性能更高的协程池时，可以尝试下 goes。
+> 很明显，goes.Executor 的性能比功能更丰富的 ants.Pool 要高出 5 倍左右，所以当你需要一个很轻量且高性能的异步任务执行器时，可以尝试下 goes。
 
 > 测试文件：[_examples/performance_test.go](./_examples/performance_test.go)。
 

_examples/basic.go

@@ -12,14 +12,26 @@ import (
 )
 
 func main() {
+	// Limits the number of simultaneous goroutines and not reuses them.
 	limiter := goes.NewLimiter(4)
 
-	for i := 0; i < 100; i++ {
+	for i := 0; i < 20; i++ {
 		limiter.Go(func() {
-			fmt.Println(time.Now())
-			time.Sleep(100 * time.Millisecond)
+			fmt.Println("limiter --> ", time.Now())
+			time.Sleep(time.Second)
 		})
 	}
 
 	limiter.Wait()
+
+	// Limits the number of simultaneous goroutines and reuses them.
+	executor := goes.NewExecutor(4)
+	defer executor.Close()
+
+	for i := 0; i < 20; i++ {
+		executor.Submit(func() {
+			fmt.Println("executor --> ", time.Now())
+			time.Sleep(time.Second)
+		})
+	}
 }

_examples/performance_test.go

@@ -14,9 +14,10 @@ import (
 )
 
 const (
-	limit    = 256
-	size     = 256
-	timeLoop = 100_0000
+	limit     = 256
+	workerNum = limit
+	size      = limit
+	timeLoop  = 100_0000
 )
 
 func bench(num *uint32) {
@@ -62,9 +63,9 @@ func BenchmarkLimiterTime(b *testing.B) {
 	b.Logf("num is %d, cost is %s", num, cost)
 }
 
-// go test -v -run=none -bench=^BenchmarkPool$ -benchmem -benchtime=1s
-func BenchmarkPool(b *testing.B) {
-	pool := goes.NewPool(size)
+// go test -v -run=none -bench=^BenchmarkExecutor$ -benchmem -benchtime=1s
+func BenchmarkExecutor(b *testing.B) {
+	executor := goes.NewExecutor(workerNum)
 
 	num := uint32(0)
 	task := func() {
@@ -73,17 +74,17 @@ func BenchmarkPool(b *testing.B) {
 
 	b.RunParallel(func(pb *testing.PB) {
 		for pb.Next() {
-			pool.Submit(task)
+			executor.Submit(task)
 		}
 	})
 
-	pool.Close()
+	executor.Close()
 	b.Logf("num is %d", num)
 }
 
-// go test -v -run=none -bench=^BenchmarkPoolTime$ -benchmem -benchtime=1s
-func BenchmarkPoolTime(b *testing.B) {
-	pool := goes.NewPool(size)
+// go test -v -run=none -bench=^BenchmarkExecutorTime$ -benchmem -benchtime=1s
+func BenchmarkExecutorTime(b *testing.B) {
+	executor := goes.NewExecutor(size)
 
 	num := uint32(0)
 	task := func() {
@@ -92,10 +93,10 @@ func BenchmarkPoolTime(b *testing.B) {
 
 	beginTime := time.Now()
 	for range timeLoop {
-		pool.Submit(task)
+		executor.Submit(task)
 	}
 
-	pool.Close()
+	executor.Close()
 
 	cost := time.Since(beginTime)
 	b.Logf("num is %d, cost is %s", num, cost)

_icons/coverage.svg

@@ -11,18 +11,18 @@ import (
 )
 
 type config struct {
-	size          int
-	queueSize     int
-	recoverFunc   func(r any)
-	newLockerFunc func() sync.Locker
+	workerNum       int
+	workerQueueSize int
+	recoverFunc     func(r any)
+	newLockerFunc   func() sync.Locker
 }
 
-func newDefaultConfig(size int) *config {
+func newDefaultConfig(workerNum int) *config {
 	return &config{
-		size:          size,
-		queueSize:     64,
-		recoverFunc:   nil,
-		newLockerFunc: nil,
+		workerNum:       workerNum,
+		workerQueueSize: 64,
+		recoverFunc:     nil,
+		newLockerFunc:   nil,
 	}
 }
 

config.go

@@ -12,18 +12,18 @@ import (
 
 // go test -v -cover -run=^TestNewDefaultConfig$
 func TestNewDefaultConfig(t *testing.T) {
-	size := 16
-	conf := newDefaultConfig(size)
+	workerNum := 16
+	conf := newDefaultConfig(workerNum)
 
-	if conf.size != size {
-		t.Fatalf("conf.size %d != size %d", conf.size, size)
+	if conf.workerNum != workerNum {
+		t.Fatalf("conf.workerNum %d != workerNum %d", conf.workerNum, workerNum)
 	}
 }
 
 // go test -v -cover -run=^TestConfigRecover$
 func TestConfigRecover(t *testing.T) {
-	size := 16
-	conf := newDefaultConfig(size)
+	workerNum := 16
+	conf := newDefaultConfig(workerNum)
 	conf.recover(0)
 
 	got := 0
@@ -41,8 +41,8 @@ func TestConfigRecover(t *testing.T) {
 
 // go test -v -cover -run=^TestConfigNewLocker$
 func TestConfigNewLocker(t *testing.T) {
-	size := 16
-	conf := newDefaultConfig(size)
+	workerNum := 16
+	conf := newDefaultConfig(workerNum)
 	conf.newLocker()
 
 	want := &sync.Mutex{}