Use custom go pool

[cocktail18]

conc would spawns a new goroutine when pool.Go call each time.
It would cause waste of resources in some case.
Is it had a plan to use a custom goroutine pool instead of spawn every time ?
for example:

type gPool interface {
    Do(func (){})
}

pool.NewWithCustomPool(gPool)

[ljluestc]

package conc

import (
	"context"
	"sync"
)

// gPool defines an interface for a custom goroutine pool.
type gPool interface {
	Do(func())
}

// Pool is the modified conc.Pool struct with support for a custom goroutine pool.
type Pool struct {
	ctx        context.Context
	cancel     func()
	wg         sync.WaitGroup
	tasks      chan func()
	customPool gPool
}

// Option is a function that configures a Pool.
type Option func(*Pool)

// WithCustomPool sets a custom goroutine pool for the Pool.
func WithCustomPool(pool gPool) Option {
	return func(p *Pool) {
		p.customPool = pool
	}
}

// NewWithCustomPool creates a new Pool with the given options, including an optional custom goroutine pool.
func NewWithCustomPool(opts ...Option) *Pool {
	ctx, cancel := context.WithCancel(context.Background())
	p := &Pool{
		ctx:    ctx,
		cancel: cancel,
		tasks:  make(chan func()),
	}

	for _, opt := range opts {
		opt(p)
	}

	// If no custom pool is provided, start a default task processor.
	if p.customPool == nil {
		go p.processTasks()
	}

	return p
}

// Go submits a task to the pool, using the custom pool if available.
func (p *Pool) Go(f func()) {
	p.wg.Add(1)
	if p.customPool != nil {
		// Use the custom pool to execute the task.
		p.customPool.Do(func() {
			defer p.wg.Done()
			f()
		})
	} else {
		// Default behavior: submit to the internal task channel.
		select {
		case p.tasks <- func() {
			defer p.wg.Done()
			f()
		}:
		case <-p.ctx.Done():
			p.wg.Done()
		}
	}
}

// processTasks runs a default task processor for the Pool if no custom pool is used.
func (p *Pool) processTasks() {
	for {
		select {
		case task := <-p.tasks:
			task()
		case <-p.ctx.Done():
			return
		}
	}
}

// Wait waits for all tasks to complete and closes the pool.
func (p *Pool) Wait() {
	p.wg.Wait()
	p.cancel()
}

// SimpleGoroutinePool is an example implementation of gPool with a fixed number of workers.
type SimpleGoroutinePool struct {
	tasks   chan func()
	workers int
	wg      sync.WaitGroup
	ctx     context.Context
	cancel  func()
}

// NewSimpleGoroutinePool creates a new SimpleGoroutinePool with the specified number of workers.
func NewSimpleGoroutinePool(workers int) *SimpleGoroutinePool {
	ctx, cancel := context.WithCancel(context.Background())
	p := &SimpleGoroutinePool{
		tasks:   make(chan func(), 100), // Buffered channel for tasks.
		workers: workers,
		ctx:     ctx,
		cancel​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​