增加选项初始化

Author: FishGoddess

FUTURE.md

@@ -1,9 +1,19 @@
 ## ✒ 未来版本的新特性 (Features in future versions)
 
+### v0.2.x
+
+* [x] 增加轻量的协程池
+* [x] 支持轮训调度策略
+* [ ] 支持随机调度策略
+* [ ] 支持最少任务优先调度策略
+* [x] 支持设置 worker 任务队列大小
+* [x] 支持设置 panic 处理函数
+* [ ] 支持选择使用自旋锁还是互斥锁
+* [ ] 完善单元测试
+
 ### v0.1.0
 
 * [x] 增加支持退避策略的自旋锁
-* [ ] 增加轻量协程库
 
 ### v0.0.1
 

Makefile

@@ -3,7 +3,7 @@
 all: test
 
 test:
-	go test -cover ./...
+	go test -v -cover ./...
 
 bench:
 	go test -v ./_examples/performance_test.go -run=none -bench=. -benchmem -benchtime=1s

_examples/performance_test.go

@@ -15,7 +15,7 @@ import (
 
 const (
 	limit    = 256
-	size     = limit
+	size     = 256
 	timeLoop = 100_0000
 )
 
@@ -64,8 +64,7 @@ func BenchmarkLimiterTime(b *testing.B) {
 
 // go test -v -run=none -bench=^BenchmarkPool$ -benchmem -benchtime=1s
 func BenchmarkPool(b *testing.B) {
-	workerLimit := 1024
-	pool := goes.NewPool(size, workerLimit)
+	pool := goes.NewPool(size)
 
 	num := uint32(0)
 	task := func() {
@@ -84,8 +83,7 @@ func BenchmarkPool(b *testing.B) {
 
 // go test -v -run=none -bench=^BenchmarkPoolTime$ -benchmem -benchtime=1s
 func BenchmarkPoolTime(b *testing.B) {
-	workerLimit := 1024
-	pool := goes.NewPool(size, workerLimit)
+	pool := goes.NewPool(size)
 
 	num := uint32(0)
 	task := func() {

option.go

@@ -0,0 +1,40 @@
+// Copyright 2025 FishGoddess. All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package goes
+
+type config struct {
+	size        int
+	queueSize   int
+	recoverFunc func(r any)
+}
+
+func newDefaultConfig(size int) *config {
+	return &config{
+		size:        size,
+		queueSize:   64,
+		recoverFunc: nil,
+	}
+}
+
+// Option is for setting config.
+type Option func(conf *config)
+
+func (o Option) applyTo(conf *config) {
+	o(conf)
+}
+
+// WithQueueSize sets the queue size of worker.
+func WithQueueSize(size int) Option {
+	return func(conf *config) {
+		conf.queueSize = size
+	}
+}
+
+// WithRecoverFunc sets the recover function of worker.
+func WithRecoverFunc(f func(r any)) Option {
+	return func(conf *config) {
+		conf.recoverFunc = f
+	}
+}

option_test.go

@@ -0,0 +1,44 @@
+// Copyright 2025 FishGoddess. All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package goes
+
+import (
+	"fmt"
+	"testing"
+)
+
+// go test -v -cover -run=^TestNewDefaultConfig$
+func TestNewDefaultConfig(t *testing.T) {
+	size := 16
+	conf := newDefaultConfig(size)
+
+	if conf.size != size {
+		t.Fatalf("conf.size %d != size %d", conf.size, size)
+	}
+}
+
+// go test -v -cover -run=^TestWithQueueSize$
+func TestWithQueueSize(t *testing.T) {
+	size := 16
+	queueSize := 256
+	conf := newDefaultConfig(size)
+	WithQueueSize(queueSize)(conf)
+
+	if conf.queueSize != queueSize {
+		t.Fatalf("conf.queueSize %d != queueSize %d", conf.queueSize, queueSize)
+	}
+}
+
+// go test -v -cover -run=^TestWithRecoverFunc$
+func TestWithRecoverFunc(t *testing.T) {
+	size := 16
+	recoverFunc := func(r any) {}
+	conf := newDefaultConfig(size)
+	WithRecoverFunc(recoverFunc)(conf)
+
+	if fmt.Sprintf("%p", conf.recoverFunc) != fmt.Sprintf("%p", recoverFunc) {
+		t.Fatalf("conf.recoverFunc %p != recoverFunc %p", conf.recoverFunc, recoverFunc)
+	}
+}

pool.go

@@ -11,6 +11,8 @@ import (
 )
 
 type Pool struct {
+	conf *config
+
 	workers []*worker
 	index   int
 	closed  bool
@@ -19,20 +21,30 @@ type Pool struct {
 	lock sync.Locker
 }
 
-func NewPool(size int, workerLimit int) *Pool {
-	if size <= 0 {
+func NewPool(size int, opts ...Option) *Pool {
+	conf := newDefaultConfig(size)
+	for _, opt := range opts {
+		opt.applyTo(conf)
+	}
+
+	if conf.size <= 0 {
 		panic("goes: pool size <= 0")
 	}
 
+	if conf.queueSize <= 0 {
+		panic("goes: worker queue size <= 0")
+	}
+
 	pool := &Pool{
+		conf:    conf,
 		workers: make([]*worker, 0, size),
 		index:   0,
 		closed:  false,
 		lock:    spinlock.New(),
 	}
 
 	for range size {
-		worker := newWorker(pool, workerLimit)
+		worker := newWorker(pool)
 		pool.workers = append(pool.workers, worker)
 	}
 

pool_test.go

@@ -13,8 +13,8 @@ import (
 // go test -v -cover -run=^TestPool$
 func TestPool(t *testing.T) {
 	size := 16
-	workerLimit := 1024
-	pool := NewPool(size, workerLimit)
+	queueSize := 1024
+	pool := NewPool(size, WithQueueSize(queueSize))
 
 	var countMap = make(map[int64]int, 16)
 	var lock sync.Mutex

worker.go

@@ -9,14 +9,10 @@ type worker struct {
 	tasks chan func()
 }
 
-func newWorker(pool *Pool, limit int) *worker {
-	if limit <= 0 {
-		panic("goes: worker limit <= 0")
-	}
-
+func newWorker(pool *Pool) *worker {
 	w := &worker{
 		pool:  pool,
-		tasks: make(chan func(), limit),
+		tasks: make(chan func(), pool.conf.queueSize),
 	}
 
 	w.work()
@@ -28,11 +24,13 @@ func (w *worker) handle(task func()) {
 		return
 	}
 
-	defer func() {
-		if r := recover(); r != nil {
-			panic(r) // TODO recover from panic
-		}
-	}()
+	if w.pool.conf.recoverFunc != nil {
+		defer func() {
+			if r := recover(); r != nil {
+				w.pool.conf.recoverFunc(r)
+			}
+		}()
+	}
 
 	task()
 }