关于golang:聊聊gost的GenericTaskPool

序

本文次要钻研一下 gost 的 GenericTaskPool

GenericTaskPool

gost/sync/task_pool.go

// GenericTaskPool represents an generic task pool.
type GenericTaskPool interface {
    // AddTask wait idle worker add task
    AddTask(t task) bool
    // AddTaskAlways add task to queues or do it immediately
    AddTaskAlways(t task)
    // AddTaskBalance add task to idle queue
    AddTaskBalance(t task)
    // Close use to close the task pool
    Close()
    // IsClosed use to check pool status.
    IsClosed() bool}

GenericTaskPool 接口定义了 AddTask、AddTaskAlways、AddTaskBalance、Close、IsClosed 接口

TaskPool

gost/sync/task_pool.go

type TaskPool struct {
    TaskPoolOptions

    idx    uint32 // round robin index
    qArray []chan task
    wg     sync.WaitGroup

    once sync.Once
    done chan struct{}}

// return false when the pool is stop
func (p *TaskPool) AddTask(t task) (ok bool) {idx := atomic.AddUint32(&p.idx, 1)
    id := idx % uint32(p.tQNumber)

    select {
    case <-p.done:
        return false
    default:
        p.qArray[id] <- t
        return true
    }
}

func (p *TaskPool) AddTaskAlways(t task) {id := atomic.AddUint32(&p.idx, 1) % uint32(p.tQNumber)

    select {case p.qArray[id] <- t:
        return
    default:
        goSafely(t)
    }
}

// do it immediately when no idle queue
func (p *TaskPool) AddTaskBalance(t task) {length := len(p.qArray)

    // try len/2 times to lookup idle queue
    for i := 0; i < length/2; i++ {
        select {case p.qArray[rand.Intn(length)] <- t:
            return
        default:
            continue
        }
    }

    goSafely(t)
}

// check whether the session has been closed.
func (p *TaskPool) IsClosed() bool {
    select {
    case <-p.done:
        return true

    default:
        return false
    }
}

func (p *TaskPool) Close() {p.stop()
    p.wg.Wait()
    for i := range p.qArray {close(p.qArray[i])
    }
}

TaskPool 定义了 TaskPoolOptions、idx、qArray、wg、once、done 属性；它实现了 GenericTaskPool 接口；AddTask 办法在 pool 是 done 的时候会返回 false，其余状况会递增 idx，而后依据 tQNumber 计算 id，往 qArray[id] 写入 task；AddTaskAlways 办法会疏忽 pool 的敞开信息；AddTaskBalance 办法会尝试 len/ 2 次随机往 qArray 写入 task，都写入不胜利则 goSafely 执行；IsClosed 次要是读取 done 的 channel 信息；Close 办法执行 stop 及 wg.Wait()，最初遍历 qArray 挨个执行 close

NewTaskPool

gost/sync/task_pool.go

func NewTaskPool(opts ...TaskPoolOption) GenericTaskPool {
    var tOpts TaskPoolOptions
    for _, opt := range opts {opt(&tOpts)
    }

    tOpts.validate()

    p := &TaskPool{
        TaskPoolOptions: tOpts,
        qArray:          make([]chan task, tOpts.tQNumber),
        done:            make(chan struct{}),
    }

    for i := 0; i < p.tQNumber; i++ {p.qArray[i] = make(chan task, p.tQLen)
    }
    p.start()

    return p
}

NewTaskPool 通过 TaskPoolOptions 来创立 TaskPool

TaskPoolOption

gost/sync/options.go

const (
    defaultTaskQNumber = 10
    defaultTaskQLen    = 128
)

/////////////////////////////////////////
// Task Pool Options
/////////////////////////////////////////

// TaskPoolOptions is optional settings for task pool
type TaskPoolOptions struct {
    tQLen      int // task queue length. buffer size per queue
    tQNumber   int // task queue number. number of queue
    tQPoolSize int // task pool size. number of workers
}

func (o *TaskPoolOptions) validate() {
    if o.tQPoolSize < 1 {panic(fmt.Sprintf("illegal pool size %d", o.tQPoolSize))
    }

    if o.tQLen < 1 {o.tQLen = defaultTaskQLen}

    if o.tQNumber < 1 {o.tQNumber = defaultTaskQNumber}

    if o.tQNumber > o.tQPoolSize {o.tQNumber = o.tQPoolSize}
}

type TaskPoolOption func(*TaskPoolOptions)

// WithTaskPoolTaskPoolSize set @size of the task queue pool size
func WithTaskPoolTaskPoolSize(size int) TaskPoolOption {return func(o *TaskPoolOptions) {o.tQPoolSize = size}
}

// WithTaskPoolTaskQueueLength set @length of the task queue length
func WithTaskPoolTaskQueueLength(length int) TaskPoolOption {return func(o *TaskPoolOptions) {o.tQLen = length}
}

// WithTaskPoolTaskQueueNumber set @number of the task queue number
func WithTaskPoolTaskQueueNumber(number int) TaskPoolOption {return func(o *TaskPoolOptions) {o.tQNumber = number}
}

TaskPoolOptions 定义了 tQLen、tQNumber、tQPoolSize 属性，提供了 WithTaskPoolTaskPoolSize、WithTaskPoolTaskQueueLength、WithTaskPoolTaskQueueNumber、validate 办法

start

gost/sync/task_pool.go

func (p *TaskPool) start() {
    for i := 0; i < p.tQPoolSize; i++ {p.wg.Add(1)
        workerID := i
        q := p.qArray[workerID%p.tQNumber]
        p.safeRun(workerID, q)
    }
}

func (p *TaskPool) safeRun(workerID int, q chan task) {
    gxruntime.GoSafely(nil, false,
        func() {err := p.run(int(workerID), q)
            if err != nil {
                // log error to stderr
                log.Printf("gost/TaskPool.run error: %s", err.Error())
            }
        },
        nil,
    )
}

start 办法依据 tQPoolSize 挨个执行 safeRun；safeRun 办法通过 GoSafely 执行 p.run(int(workerID), q)

run

gost/sync/task_pool.go

// worker
func (p *TaskPool) run(id int, q chan task) error {defer p.wg.Done()

    var (
        ok bool
        t  task
    )

    for {
        select {
        case <-p.done:
            if 0 < len(q) {
                return fmt.Errorf("task worker %d exit now while its task buffer length %d is greater than 0",
                    id, len(q))
            }

            return nil

        case t, ok = <-q:
            if ok {func() {defer func() {if r := recover(); r != nil {
                            fmt.Fprintf(os.Stderr, "%s goroutine panic: %v\n%s\n",
                                time.Now(), r, string(debug.Stack()))
                        }
                    }()
                    t()}()}
        }
    }
}

run 办法通过 for 循环进行 select，若读取到 p.done 则退出循环；若是读取到 task 则执行 task

taskPoolSimple

gost/sync/task_pool.go

type taskPoolSimple struct {
    work chan task     // task channel
    sem  chan struct{} // gr pool size

    wg sync.WaitGroup

    once sync.Once
    done chan struct{}}

taskPoolSimple 定义了 work、sem、wg、once、done 属性；它实现了 GenericTaskPool 接口；AddTask 办法先判断 done，之后写入 work 及 sem；AddTaskAlways 办法在 select 不到 channel 的时候会执行 goSafely；AddTaskBalance 办法理论执行的是 AddTaskAlways；IsClosed 办法读取 done 信息；Close 办法执行 stop 及 wg.Wait()

实例

gost/sync/task_pool_test.go

func TestTaskPool(t *testing.T) {numCPU := runtime.NumCPU()
    //taskCnt := int64(numCPU * numCPU * 100)

    tp := NewTaskPool(WithTaskPoolTaskPoolSize(1),
        WithTaskPoolTaskQueueNumber(1),
        WithTaskPoolTaskQueueLength(1),
    )

    //task, cnt := newCountTask()
    task, _ := newCountTask()

    var wg sync.WaitGroup
    for i := 0; i < numCPU*numCPU; i++ {wg.Add(1)
        go func() {
            for j := 0; j < 100; j++ {ok := tp.AddTask(task)
                if !ok {t.Log(j)
                }
            }
            wg.Done()}()}
    wg.Wait()
    tp.Close()

    //if taskCnt != atomic.LoadInt64(cnt) {//    //t.Error("want", taskCnt, "got", *cnt)
    //}
}

func TestTaskPoolSimple(t *testing.T) {numCPU := runtime.NumCPU()
    taskCnt := int64(numCPU * numCPU * 100)

    tp := NewTaskPoolSimple(1)

    task, cnt := newCountTask()

    var wg sync.WaitGroup
    for i := 0; i < numCPU*numCPU; i++ {wg.Add(1)
        go func() {
            for j := 0; j < 100; j++ {ok := tp.AddTask(task)
                if !ok {t.Log(j)
                }
            }
            wg.Done()}()}
    wg.Wait()

    cntValue := atomic.LoadInt64(cnt)
    if taskCnt != cntValue {t.Error("want", taskCnt, "got", cntValue)
    }
}

TaskPoolSimple 的创立比较简单，只须要提供 size 参数即可；TaskPool 的创立须要提供 TaskPoolOption，有 WithTaskPoolTaskPoolSize、WithTaskPoolTaskQueueNumber、WithTaskPoolTaskQueueLength 这些 option

小结

gost 的 GenericTaskPool 接口定义了 AddTask、AddTaskAlways、AddTaskBalance、Close、IsClosed 接口；这里有 TaskPool、taskPoolSimple 两个实现。

doc

• gost