快捷導(dǎo)航

golang的tunny的用法示例教程

更新時間：2023年07月14日 13:59:58 作者：codecraft

這篇文章主要為大家介紹了golang的tunny的用法示例教程，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進(jìn)步，早日升職加薪

序

本文主要研究一下tunny

Worker

type Worker interface {
    // Process will synchronously perform a job and return the result.
    Process(interface{}) interface{}
    // BlockUntilReady is called before each job is processed and must block the
    // calling goroutine until the Worker is ready to process the next job.
    BlockUntilReady()
    // Interrupt is called when a job is cancelled. The worker is responsible
    // for unblocking the Process implementation.
    Interrupt()
    // Terminate is called when a Worker is removed from the processing pool
    // and is responsible for cleaning up any held resources.
    Terminate()
}

Worker接口定義了Process、BlockUntilReady、Interrupt、Terminate方法

closureWorker

type closureWorker struct {
    processor func(interface{}) interface{}
}
func (w *closureWorker) Process(payload interface{}) interface{} {
    return w.processor(payload)
}
func (w *closureWorker) BlockUntilReady() {}
func (w *closureWorker) Interrupt()       {}
func (w *closureWorker) Terminate()       {}

closureWorker定義了processor屬性，它實現(xiàn)了Worker接口的Process、BlockUntilReady、Interrupt、Terminate方法，其中Process方法委托給processor

callbackWorker

type callbackWorker struct{}
func (w *callbackWorker) Process(payload interface{}) interface{} {
    f, ok := payload.(func())
    if !ok {
        return ErrJobNotFunc
    }
    f()
    return nil
}
func (w *callbackWorker) BlockUntilReady() {}
func (w *callbackWorker) Interrupt()       {}
func (w *callbackWorker) Terminate()       {}

callbackWorker定義了processor屬性，它實現(xiàn)了Worker接口的Process、BlockUntilReady、Interrupt、Terminate方法，其中Process方法執(zhí)行的是payload函數(shù)

Pool

type Pool struct {
    queuedJobs int64
    ctor    func() Worker
    workers []*workerWrapper
    reqChan chan workRequest
    workerMut sync.Mutex
}
func New(n int, ctor func() Worker) *Pool {
    p := &Pool{
        ctor:    ctor,
        reqChan: make(chan workRequest),
    }
    p.SetSize(n)
    return p
}
func NewFunc(n int, f func(interface{}) interface{}) *Pool {
    return New(n, func() Worker {
        return &closureWorker{
            processor: f,
        }
    })
}
func NewCallback(n int) *Pool {
    return New(n, func() Worker {
        return &callbackWorker{}
    })
}

Pool定義了queuedJobs、ctor、workers、reqChan、workerMut屬性；New方法根據(jù)n和ctor創(chuàng)建Pool；NewFunc方法根據(jù)n和f來創(chuàng)建closureWorker；NewCallback方法創(chuàng)建callbackWorker

Process

func (p *Pool) Process(payload interface{}) interface{} {
    atomic.AddInt64(&p.queuedJobs, 1)
    request, open := <-p.reqChan
    if !open {
        panic(ErrPoolNotRunning)
    }
    request.jobChan <- payload
    payload, open = <-request.retChan
    if !open {
        panic(ErrWorkerClosed)
    }
    atomic.AddInt64(&p.queuedJobs, -1)
    return payload
}

Process方法首先遞增queuedJobs，然后從reqChan讀取request，然后往jobChan寫入payload，之后再等待retChan，最后遞減queuedJobs

SetSize

func (p *Pool) SetSize(n int) {
    p.workerMut.Lock()
    defer p.workerMut.Unlock()
    lWorkers := len(p.workers)
    if lWorkers == n {
        return
    }
    // Add extra workers if N > len(workers)
    for i := lWorkers; i < n; i++ {
        p.workers = append(p.workers, newWorkerWrapper(p.reqChan, p.ctor()))
    }
    // Asynchronously stop all workers > N
    for i := n; i < lWorkers; i++ {
        p.workers[i].stop()
    }
    // Synchronously wait for all workers > N to stop
    for i := n; i < lWorkers; i++ {
        p.workers[i].join()
    }
    // Remove stopped workers from slice
    p.workers = p.workers[:n]
}

SetSize方法首先通過workerMut加鎖，然后根據(jù)lWorkers創(chuàng)建newWorkerWrapper，之后執(zhí)行worker.stop，再執(zhí)行worker.join()，然后清空workers

Close

func (p *Pool) Close() {
    p.SetSize(0)
    close(p.reqChan)
}

Close方法執(zhí)行SetSize(0)及close(p.reqChan)

實例

func TestFuncJob(t *testing.T) {
    pool := NewFunc(10, func(in interface{}) interface{} {
        intVal := in.(int)
        return intVal * 2
    })
    defer pool.Close()
    for i := 0; i < 10; i++ {
        ret := pool.Process(10)
        if exp, act := 20, ret.(int); exp != act {
            t.Errorf("Wrong result: %v != %v", act, exp)
        }
    }
}

TestFuncJob通過NewFunc創(chuàng)建pool，