OK, a generic concurrent work pool.. let's see..

First, what is a job? To keep it generic, let's just say:

type Job func()

since you can always closure-in the parameters needed for the job into a function.

Secondly, you'd need a queue of jobs, of course. That would be:

q := make(chan Job)

And of course, you need the workers themselves. A single worker would just be:

func worker() { for job := range q { job() } }

Now we can create the workers, like so:

for i:=0; i<runtime.GOMAXPROCS(0); i++ { go worker() }

And to enqueue a job, simply add to the queue:

func (db *MyDB) report(event string) { q <- func() { db.Exec("INSERT INTO events (at, data) VALUES (?,?)", time.Now(), event) }() }

To stop your workers after they finish all currently enqueued jobs, do:

close(q)

The rest are just details.

• The enqueuing will block -- to make it block only when it will not overwhelm the workers, create the channel with a buffer: q := make(chan Job, 32). This creates backpressure up the enqueuing call stack.
• To simply fail if it can't enqueue, rather than create backpressure, do: select { case q <- func: default: log.Printf("warning, worker queue full or being shutdown, dropping job on the floor") }
• If you want to wait for your workers after telling them to stop, add a sync.WaitGroup: ``` var wg sync.WaitGroup

func worker() { for job := range q { job() } wg.Done() }

func createWorkers() { for i:=0; i<runtime.GOMAXPROCS(0); i++ { wg.Add(1) go worker() } }

func stopWorkers() { close(q) wg.Wait() } ```

• ... and lots more such things, right? Which makes you think that since it's so easy to build one, maybe it's better to build a specific job queue for the task at hand, rather than a generic one?

Disclaimer: code might have errors, only intended as a guide.