go func() {
	// do your job
}()

import (
    "github.com/bytedance/gopkg/util/gopool"
)

gopool.Go(func(){
	/// do your job
})

type Pool interface {
	// 池子的名稱
	Name() string
        
	// 設(shè)置池子內(nèi)Goroutine的容量
	SetCap(cap int32)
        
	// 執(zhí)行 f 函數(shù)
	Go(f func())
        
	// 帶 ctx，執(zhí)行 f 函數(shù)
	CtxGo(ctx context.Context, f func())
        
	// 設(shè)置發(fā)生panic時調(diào)用的函數(shù)
	SetPanicHandler(f func(context.Context, interface{}))
}

type pool struct {
	// 池子名稱
	name string

	// 池子的容量, 即最大并發(fā)工作的 goroutine 的數(shù)量
	cap int32
        
	// 池子配置
	config *Config
        
	// task 鏈表
	taskHead  *task
	taskTail  *task
	taskLock  sync.Mutex
	taskCount int32

	// 記錄當(dāng)前正在運行的 worker 的數(shù)量
	workerCount int32

	// 當(dāng) worker 出現(xiàn)panic時被調(diào)用
	panicHandler func(context.Context, interface{})
}

// NewPool 創(chuàng)建一個新的協(xié)程池，初始化名稱，容量，配置
func NewPool(name string, cap int32, config *Config) Pool {
	p := &pool{
		name:   name,
		cap:    cap,
		config: config,
	}
	return p
}

type task struct {
	ctx context.Context
	f   func()

	next *task
}

type worker struct {
	pool *pool
}

func (w *worker) run() {
	go func() {
		for {
                        // 聲明即將執(zhí)行的 task
			var t *task
                        
                        // 操作 pool 中的 task 鏈表，加鎖
			w.pool.taskLock.Lock()
			if w.pool.taskHead != nil {
                                // 拿到 taskHead 準(zhǔn)備執(zhí)行
				t = w.pool.taskHead
                                
                                // 更新鏈表的 head 以及數(shù)量
				w.pool.taskHead = w.pool.taskHead.next
				atomic.AddInt32(&w.pool.taskCount, -1)
			}
                        // 如果前一步拿到的 taskHead 為空，說明無任務(wù)需要執(zhí)行，清理后返回
			if t == nil {
				w.close()
				w.pool.taskLock.Unlock()
				w.Recycle()
				return
			}
			w.pool.taskLock.Unlock()
                        
                        // 執(zhí)行任務(wù)，針對 panic 會recover，并調(diào)用配置的 handler
			func() {
				defer func() {
					if r := recover(); r != nil {
						msg := fmt.Sprintf("GOPOOL: panic in pool: %s: %v: %s", w.pool.name, r, debug.Stack())
						logger.CtxErrorf(t.ctx, msg)
						if w.pool.panicHandler != nil {
							w.pool.panicHandler(t.ctx, r)
						}
					}
				}()
				t.f()
			}()
			t.Recycle()
		}
	}()
}

func Go(f func()) {
	CtxGo(context.Background(), f)
}

func CtxGo(ctx context.Context, f func()) {
	defaultPool.CtxGo(ctx, f)
}

func (p *pool) CtxGo(ctx context.Context, f func()) {

        // 創(chuàng)建一個 task 對象，將 ctx 和待執(zhí)行的函數(shù)賦值
	t := taskPool.Get().(*task)
	t.ctx = ctx
	t.f = f
        
        // 將 task 插入 pool 的鏈表的尾部，更新鏈表數(shù)量
	p.taskLock.Lock()
	if p.taskHead == nil {
		p.taskHead = t
		p.taskTail = t
	} else {
		p.taskTail.next = t
		p.taskTail = t
	}
	p.taskLock.Unlock()
	atomic.AddInt32(&p.taskCount, 1)
        
        
	// 以下兩個條件滿足時，創(chuàng)建新的 worker 并喚起執(zhí)行：
	// 1. task的數(shù)量超過了配置的限制 
	// 2. 當(dāng)前運行的worker數(shù)量小于上限（或無worker運行）
	if (atomic.LoadInt32(&p.taskCount) >= p.config.ScaleThreshold && p.WorkerCount() < atomic.LoadInt32(&p.cap)) || p.WorkerCount() == 0 {
        
                // worker數(shù)量+1
		p.incWorkerCount()
                
                // 創(chuàng)建一個新的worker，并把當(dāng)前 pool 賦值
		w := workerPool.Get().(*worker)
		w.pool = p
                
                // 喚起worker執(zhí)行
		w.run()
	}
}

func init() {
	defaultPool = NewPool("gopool.DefaultPool", 10000, NewConfig())
}

const (
	defaultScalaThreshold = 1
)

// Config is used to config pool.
type Config struct {
	// 控制擴容的門檻，一旦待執(zhí)行的 task 超過此值，且 worker 數(shù)量未達(dá)到上限，就開始啟動新的 worker
	ScaleThreshold int32
}

// NewConfig creates a default Config.
func NewConfig() *Config {
	c := &Config{
		ScaleThreshold: defaultScalaThreshold,
	}
	return c
}

var taskPool sync.Pool

func init() {
	taskPool.New = newTask
}

func newTask() interface{} {
	return &task{}
}

func (t *task) Recycle() {
	t.zero()
	taskPool.Put(t)
}

var workerPool sync.Pool

func init() {
	workerPool.New = newWorker
}

func newWorker() interface{} {
	return &worker{}
}

func (w *worker) Recycle() {
	w.zero()
	workerPool.Put(w)
}