const ROUTINES = 2;
for {
			var wg sync.WaitGroup
			_, err:= db.Exec(`Random DB Call`)
			if err != nil {
				panic(err)
			}
			ch := createRoutines(db, &wg)
			wg.Add(ROUTINES)
			for i := 1; i <= ROUTINES; i++ {
				ch <- i
				time.Sleep(2 * time.Second)
			}
			close(ch)
			wg.Wait() 
		}
func createRoutines(db *sqlx.DB, wg *sync.WaitGroup) chan int {
	var ch = make(chan int, 5)
	for i := 0; i < ROUTINES ; i++ {
		go func(db *sqlx.DB) {
			defer wg.Done()
			for {
				_, ok := <-ch
				if !ok { 
					return
				}
				doStuff(db) 
			}
		}(db)
	}
	return ch
}

package main
import (
	"fmt"
	"math/rand"
	"time"
)
func main() {
	const ROUTINES = 2
	rand.Seed(time.Now().UnixNano())
	stopper := make(chan struct{}, ROUTINES)
	var counter int
	for {
		counter++
		stopper <- struct{}{}
		go func(c int) {
			fmt.Println("+ Starting goroutine", c)
			time.Sleep(time.Duration(rand.Intn(3)) * time.Second)
			fmt.Println("- Stopping goroutine", c)
			<-stopper
		}(counter)
	}
}

package main
import (
	"context"
	"database/sql"
	"log"
	"github.com/MicahParks/ctxerrpool"
)
func main() {
	// Create a pool of 2 workers for database queries. Log any errors.
	databasePool := ctxerrpool.New(2, func(_ ctxerrpool.Pool, err error) {
		log.Printf("Failed to execute database query.\nError: %s", err.Error())
	})
	// Get a list of queries to execute.
	queries := []string{
		"SELECT first_name, last_name FROM customers",
		"SELECT price FROM inventory WHERE sku='1234'",
		"other queries...",
	}
	// TODO Make a database connection.
	var db *sql.DB
	for _, query := range queries {
		// Intentionally shadow the looped variable for scope.
		query := query
		// Perform the query on a worker. If no worker is ready, it will block until one is.
		databasePool.AddWorkItem(context.TODO(), func(workCtx context.Context) (err error) {
			_, err = db.ExecContext(workCtx, query)
			return err
		})
	}
	// Wait for all workers to finish.
	databasePool.Wait()
}