func (c *balancer) get(shouldBalancing bool) *wrapper {
	if shouldBalancing {
		return c.dbs.next()
	}
	return c.dbs.current()
}
get a db to handle our query
package mssqlx
import (
	"context"
	"fmt"
	"sync/atomic"
	"time"
)
type balancer struct {
	ctx                   context.Context
	cancel                context.CancelFunc
	dbs                   *dbList
	fail                  chan *wrapper
	isWsrep               bool
	isMulti               bool
	numberOfHealthChecker int
	_                     [8]uint64  
	healthCheckPeriod     uint64
	_                     [8]uint64
}
func newBalancer(ctx context.Context, numHealthChecker int, numDbInstance int, isWsrep bool) *balancer {
	if numHealthChecker < 2 {
		numHealthChecker = 2  
	}
	c := &balancer{
		numberOfHealthChecker: numHealthChecker,
		dbs:                   &dbList{},
		fail:                  make(chan *wrapper, numDbInstance),
		isWsrep:               isWsrep,
		isMulti:               numDbInstance > 1,
		healthCheckPeriod:     DefaultHealthCheckPeriodInMilli,
	}
	c.ctx, c.cancel = context.WithCancel(ctx)
	for i := 0; i < numHealthChecker; i++ {
		go c.healthChecker()
	}
	return c
}
func (c *balancer) getHealthCheckPeriod() uint64 {
	return atomic.LoadUint64(&c.healthCheckPeriod)
}
func (c *balancer) setHealthCheckPeriod(period uint64) {
	if period == 0 {
		period = DefaultHealthCheckPeriodInMilli
	}
	atomic.StoreUint64(&c.healthCheckPeriod, period)
}
func (c *balancer) add(w *wrapper) {
	c.dbs.add(w)
}