How tunny Implements a Simple Goroutine Resource Pool in Go

tunny encapsulates goroutine processing units into a workWrapper, allowing the number of active goroutines to be limited.

The workerWrapper.run() function runs as a goroutine, placing a workRequest (the request handling unit) into reqChan and blocking until the caller retrieves it. A workRequest contains two channels: jobChan for passing input from the caller and retChan for returning the execution result.

The caller obtains a workRequest from the pool's reqChan, sends parameters through workRequest.jobChan, which triggers work.process inside workerWrapper.run() . After processing, the result is sent back via workRequest.retChan, and the worker blocks again by sending the workRequest back to reqChan for the next call.

Within workerWrapper.run() , the work variable is a user‑implemented interface. The most important method is Process(interface{}) interface{}, which performs the actual job.

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()
}

Conclusion: While tunny’s encapsulation and handling functions may not suit every scenario, its core ideas can be adapted to build custom goroutine resource pools for specific use cases.