package util import ( "math/rand" "reflect" "sync" "sync/atomic" ) // initial version comes from https://github.com/korovkin/limiter/blob/master/limiter.go // LimitedConcurrentExecutor object type LimitedConcurrentExecutor struct { limit int tokenChan chan int } func NewLimitedConcurrentExecutor(limit int) *LimitedConcurrentExecutor { // allocate a limiter instance c := &LimitedConcurrentExecutor{ limit: limit, tokenChan: make(chan int, limit), } // allocate the tokenChan: for i := 0; i < c.limit; i++ { c.tokenChan <- i } return c } // Execute adds a function to the execution queue. // if num of go routines allocated by this instance is < limit // launch a new go routine to execute job // else wait until a go routine becomes available func (c *LimitedConcurrentExecutor) Execute(job func()) { token := <-c.tokenChan go func() { defer func() { c.tokenChan <- token }() // run the job job() }() } // a different implementation, but somehow more "conservative" type OperationRequest func() type LimitedOutOfOrderProcessor struct { processorSlots uint32 processors []chan OperationRequest processorLimit int32 processorLimitCond *sync.Cond currentProcessor int32 } func NewLimitedOutOfOrderProcessor(limit int32) (c *LimitedOutOfOrderProcessor) { processorSlots := uint32(32) c = &LimitedOutOfOrderProcessor{ processorSlots: processorSlots, processors: make([]chan OperationRequest, processorSlots), processorLimit: limit, processorLimitCond: sync.NewCond(new(sync.Mutex)), } for i := 0; i < int(processorSlots); i++ { c.processors[i] = make(chan OperationRequest) } cases := make([]reflect.SelectCase, processorSlots) for i, ch := range c.processors { cases[i] = reflect.SelectCase{Dir: reflect.SelectRecv, Chan: reflect.ValueOf(ch)} } go func() { for { _, value, ok := reflect.Select(cases) if !ok { continue } request := value.Interface().(OperationRequest) c.processorLimitCond.L.Lock() for atomic.LoadInt32(&c.currentProcessor) > c.processorLimit { c.processorLimitCond.Wait() } atomic.AddInt32(&c.currentProcessor, 1) c.processorLimitCond.L.Unlock() go func() { defer atomic.AddInt32(&c.currentProcessor, -1) defer c.processorLimitCond.Signal() request() }() } }() return c } func (c *LimitedOutOfOrderProcessor) Execute(request OperationRequest) { index := rand.Uint32() % c.processorSlots c.processors[index] <- request }