code: func (p *simpleResourcePool) Get(unused string) (ManagedHandle, error) {
  	activeCount := atomic.AddInt32(p.numActive, 1)
  	if p.options.MaxActiveHandles > 0 &&
  		activeCount > p.options.MaxActiveHandles {
  
  		atomic.AddInt32(p.numActive, -1)
  		return nil, TooManyHandles{p.location}
  	}
  
  	highest := atomic.LoadInt32(p.activeHighWaterMark)
  	for activeCount > highest &&
  		!atomic.CompareAndSwapInt32(
  			p.activeHighWaterMark,
  			highest,
  			activeCount) {
  
  		highest = atomic.LoadInt32(p.activeHighWaterMark)
  	}
  
  	if h := p.getIdleHandle(); h != nil {
  		return h, nil
  	}
  
  	location, err := p.getLocation()
  	if err != nil {
  		atomic.AddInt32(p.numActive, -1)
  		return nil, err
  	}
  
  	if p.openTokens != nil {
  		// Current implementation does not wait for tokens to become available.
  		// If that causes availability hits, we could increase the wait,
  		// similar to simple_pool.go.
  		if p.openTokens.TryAcquire(0) {
  			defer p.openTokens.Release()
  		} else {
  			// We could not immediately acquire a token.
  			// Instead of waiting
  			atomic.AddInt32(p.numActive, -1)
  			return nil, OpenHandleError{
  				p.location, errors.New("Open Error: reached OpenMaxConcurrency")}
  		}
  	}
  
  	handle, err := p.options.Open(location)
  	if err != nil {
  		atomic.AddInt32(p.numActive, -1)
  		return nil, OpenHandleError{p.location, err}
  	}
  
  	return NewManagedHandle(p.location, handle, p, p.options), nil
  }
docs: // This gets an active resource from the resource pool.  Note that the
  // resourceLocation argument is ignored (The handles are associated to the
  // resource location provided by the first Register call).