type Builder interface {
	Build(cc ClientConn, opts BuildOptions) Balancer
	Name() string
}

type ClientConn interface {
	UpdateState(State)
	ResolveNow(resolver.ResolveNowOptions)
	
	// Deprecated
	NewSubConn([]resolver.Address, NewSubConnOptions) (SubConn, error)
	RemoveSubConn(SubConn)
	UpdateAddresses(SubConn, []resolver.Address)
	Target() string
}

type State struct {
	ConnectivityState connectivity.State
	Picker Picker
}

const (
	Idle State = iota
	Connecting
	Ready
	TransientFailure
	Shutdown
)

type Picker interface {
	Pick(info PickInfo) (PickResult, error)
}

type PickInfo struct {
	FullMethodName string
	Ctx context.Context
}

type PickResult struct {
	SubConn SubConn
	Done func(DoneInfo)
	Metadata metadata.MD
}

type SubConn interface {
	Connect()
	GetOrBuildProducer(ProducerBuilder) (p Producer, close func())
	Shutdown()
	
	// Deprecated
	UpdateAddresses([]resolver.Address)
}

type Balancer interface {
	UpdateClientConnState(ClientConnState) error
	ResolverError(error)
	Close()
 	
	// Deprecated
	UpdateSubConnState(SubConn, SubConnState)
}

type ClientConnState struct {
	ResolverState resolver.State
	BalancerConfig serviceconfig.LoadBalancingConfig
}

type State struct {
	Addresses []Address
	Endpoints []Endpoint
	ServiceConfig *serviceconfig.ParseResult
	Attributes *attributes.Attributes
}

// This sets the initial balancing policy.
grpc.WithDefaultServiceConfig(`{"loadBalancingConfig": [{"round_robin":{}}]}`), 

func NewBalancerBuilder(name string, pb PickerBuilder, config Config) balancer.Builder {
	return &baseBuilder{
		name:          name,
		pickerBuilder: pb,
		config:        config,
	}
}

type PickerBuilder interface {
	// Build returns a picker that will be used by gRPC to pick a SubConn.
	Build(info PickerBuildInfo) balancer.Picker
}

func Register(b Builder) {
	name := strings.ToLower(b.Name())
	if name != b.Name() {
		// TODO: Skip the use of strings.ToLower() to index the map after v1.59
		// is released to switch to case sensitive balancer registry. Also,
		// remove this warning and update the docstrings for Register and Get.
		logger.Warningf("Balancer registered with name %q. grpc-go will be switching to case sensitive balancer registries soon", b.Name())
	}
	m[name] = b
}

func (gsb *Balancer) UpdateClientConnState(state balancer.ClientConnState) error {
	...
			balToUpdate, err = gsb.switchTo(gsbCfg.childBuilder)
	...
}

func (gsb *Balancer) switchTo(builder balancer.Builder) (*balancerWrapper, error) {
	...
	bw := &balancerWrapper{
		builder: builder,
		gsb:     gsb,
		lastState: balancer.State{
			ConnectivityState: connectivity.Connecting,
			Picker:            base.NewErrPicker(balancer.ErrNoSubConnAvailable),
		},
		subconns: make(map[balancer.SubConn]bool),
	}
	...
	newBalancer := builder.Build(bw, gsb.bOpts)
	...
	bw.Balancer = newBalancer
	return bw, nil
}

func (ccb *ccBalancerWrapper) UpdateState(s balancer.State) {
	...
	ccb.cc.pickerWrapper.updatePicker(s.Picker)
	ccb.cc.csMgr.updateState(s.ConnectivityState)
}

func (ccb *ccBalancerWrapper) NewSubConn(addrs []resolver.Address, opts balancer.NewSubConnOptions) (balancer.SubConn, error) {
	...
	ac, err := ccb.cc.newAddrConnLocked(addrs, opts)
	...
	acbw := &acBalancerWrapper{
		ccb:           ccb,
		ac:            ac,
		producers:     make(map[balancer.ProducerBuilder]*refCountedProducer),
		stateListener: opts.StateListener,
	}
	ac.acbw = acbw
	return acbw, nil
}

func (cc *ClientConn) newAddrConnLocked(addrs []resolver.Address, opts balancer.NewSubConnOptions) (*addrConn, error) {
	...
	ac := &addrConn{
		state:          connectivity.Idle,
		cc:             cc,
		addrs:          copyAddresses(addrs),
		scopts:         opts,
		dopts:          cc.dopts,
		channelz:       channelz.RegisterSubChannel(cc.channelz, ""),
		resetBackoff:   make(chan struct{}),
		stateReadyChan: make(chan struct{}),
	}
	...
	cc.conns[ac] = struct{}{}
	return ac, nil
}

type pickfirstBalancer struct {
	logger  *internalgrpclog.PrefixLogger
	// balancer 的状态，如Idle、Connecting、Ready、TransientFailure、Shutdown
	state   connectivity.State
	cc      balancer.ClientConn
	subConn balancer.SubConn
}

func (p *picker) Pick(balancer.PickInfo) (balancer.PickResult, error) {
	return p.result, p.err
}

func (ac *addrConn) tryAllAddrs(ctx context.Context, addrs []resolver.Address, connectDeadline time.Time) error {
	...
	for _, addr := range addrs {
		...
		err := ac.createTransport(ctx, addr, copts, connectDeadline)
		if err == nil {
			return nil
		}
		...
	}
	...
}

type rrPicker struct {
	// subConns is the snapshot of the roundrobin balancer when this picker was
	// created. The slice is immutable. Each Get() will do a round robin
	// selection from it and return the selected SubConn.
	subConns []balancer.SubConn
	next     uint32
}

func (p *rrPicker) Pick(balancer.PickInfo) (balancer.PickResult, error) {
	subConnsLen := uint32(len(p.subConns))
	nextIndex := atomic.AddUint32(&p.next, 1)

	sc := p.subConns[nextIndex%subConnsLen]
	return balancer.PickResult{SubConn: sc}, nil
}