什么是 分布式？

// Peer 是一个后端节点
type Peer interface {
	String() string
}

// 选取（Next(factor)）一个 Peer 时由调度者所提供的参考对象，Balancer 可能会将其作为选择算法工作的因素之一。
type Factor interface {
	Factor() string
}

// Factor的具体实现实现
type FactorString string

func (s FactorString) Factor() string {
	return string(s)
}

// 负载均衡器 Balancer 持有一组 Peers 然后实现Next函数，得到一个后端节点和Constrainable（目前先当作没有看到它叭～） 当身为调度者时，想要调用 Next，却没有什么合适的“因素”提供的话，就提供 DummyFactor 好了。
type BalancerLite interface {
	Next(factor Factor) (next Peer, c Constrainable)
}
// Balancer 在选取（Next(factor)）一个 Peer 时由调度者所提供的参考对象，Balancer 可能会将其作为选择算法工作的因素之一。
type Balancer interface {
  BalancerLite
  //...more
}

package RoundRobin

import (
	"fmt"
	Balancer "github.com/VariousImplementations/LoadBalancingAlgorithm"
	"strconv"
	"sync"
	"sync/atomic"
	"time"
)

type RoundRobin struct {
	peers []Balancer.Peer
	count int64
	rw    sync.RWMutex
}

//  New 使用 Round-Robin 创建一个新的负载均衡器实例
func New(opts ...Balancer.Opt) Balancer.Balancer {
	return &RoundRobin{}
}

// RoundRobin  需要实现 Balancer接口下面的方法Balancer.Next()  Balancer.Count()  Balancer.Add() Balancer.Remove()  Balancer.Clear()
func (s *RoundRobin) Next(factor Balancer.Factor) (next Balancer.Peer, c Balancer.Constrainable) {
	next = s.miniNext()
	if fc, ok := factor.(Balancer.FactorComparable); ok {
		next, c, _ = fc.ConstrainedBy(next)
	} else if nested, ok := next.(Balancer.BalancerLite); ok {
		next, c = nested.Next(factor)
	}

	return
}

// s.count 会一直增量上去，并不会取模
// s.count 增量加1就是轮询的核心
// 这样做的用意在于如果 peers 数组发生了少量的增减变化时，最终发生选择时可能会更模棱两可。
// 但是！！！注意对于 Golang 来说，s.count 来到 int64.MaxValue 时继续加一会自动回绕到 0。
// 这一特性和多数主流编译型语言相同，都是 CPU 所提供的基本特性
// 核心的算法 s.count 对后端节点的列表长度取余
func (s *RoundRobin) miniNext() (next Balancer.Peer) {
	ni := atomic.AddInt64(&s.count, 1)
	ni--
	// 加入读锁
	s.rw.RLock()
	defer s.rw.RUnlock()
	if len(s.peers) > 0 {
		ni %= int64(len(s.peers))
		next = s.peers[ni]
	}
	fmt.Printf("s.peers[%d] is be returned\n", ni)
	return
}
func (s *RoundRobin) Count() int {
	s.rw.RLock()
	defer s.rw.RUnlock()
	return len(s.peers)
}

func (s *RoundRobin) Add(peers ...Balancer.Peer) {
	for _, p := range peers {
		s.AddOne(p)
	}
}

func (s *RoundRobin) AddOne(peer Balancer.Peer) {
	if s.find(peer) {
		return
	}
	s.rw.Lock()
	defer s.rw.Unlock()
	s.peers = append(s.peers, peer)
}

func (s *RoundRobin) find(peer Balancer.Peer) (found bool) {
	s.rw.RLock()
	defer s.rw.RUnlock()
	for _, p := range s.peers {
		if Balancer.DeepEqual(p, peer) {
			return true
		}
	}
	return
}

func (s *RoundRobin) Remove(peer Balancer.Peer) {
	// 加写锁
	s.rw.Lock()
	defer s.rw.Unlock()
	for i, p := range s.peers {
		if Balancer.DeepEqual(p, peer) {
			s.peers = append(s.peers[0:i], s.peers[i+1:]...)
			return
		}
	}
}

func (s *RoundRobin) Clear() {
	// 加写锁
	s.rw.Lock()
	defer s.rw.Unlock()
	s.peers = nil
}

func Client() {
	// wg让主进程进行等待我所有的goroutinue 完成
	wg := sync.WaitGroup{}
	// 假设我们有20个不同的客户端（goroutinue）去调用我们的服务
	wg.Add(20)
	lb := &RoundRobin{
		peers: []Balancer.Peer{
			Balancer.ExP("172.16.0.10:3500"), Balancer.ExP("172.16.0.11:3500"), Balancer.ExP("172.16.0.12:3500"),
		},
		count: 0,
	}
	for i := 0; i < 10; i++ {
		go func(t int) {
			lb.Next(Balancer.DummyFactor)
			wg.Done()
			time.Sleep(2 * time.Second)
			// 这句代码第一次运行后，读解锁。
			// 循环到第二个时，读锁定后，这个goroutine就没有阻塞，同时读成功。
		}(i)

		go func(t int) {
			str := "172.16.0." + strconv.Itoa(t) + ":3500"
			lb.Add(Balancer.ExP(str))
			fmt.Println(str + " is be added. ")
			wg.Done()
			// 这句代码让写锁的效果显示出来，写锁定下是需要解锁后才能写的。
			time.Sleep(2 * time.Second)
		}(i)
	}

	time.Sleep(5 * time.Second)
	wg.Wait()
}

package RoundRobin

import "testing"

func TestFormal(t *testing.T) {
	Client()
}

// 简单版实现
import (
	"errors"
	"fmt"
	"math/rand"
	"strconv"
)

// 随机访问中需要什么来保证随机?
type serverList struct {
	ipList []string
}

func NewserverList(str ...string) *serverList {
	return &serverList{
		ipList: append([]string{}, str...),
	}
}

func (s *serverList) AddIP(str ...string) {
	s.ipList = append(s.ipList, str...)
}

func (s *serverList) GetIPLIst() []string {
	return s.ipList
}

func (s *serverList) GetIP(i int) string {
	return s.ipList[i]
}


func Random(str ...string) (string, error) {
	serverList := NewserverList(str...)
	r := rand.Int()
	l := len(serverList.GetIPLIst())
	fmt.Printf("len %d", l)
	end := strconv.Itoa(r % l)
	fmt.Printf("end %s\n", end)
	for _, v := range serverList.GetIPLIst() {
		test := v[len(v)-1:]
		fmt.Println(test)
		if test == end {
			return v, nil
		}

	}
	/*
	return serverList.GetIP(end)
	*/
	return "", errors.New("get ip error")
}

// 测试函数
import (
	"fmt"
	"testing"
)

func TestRadom(t *testing.T) {
	re, err := Random(
		"192.168.1.0",
		"192.168.1.1",
		"192.168.1.2",
		"192.168.1.3",
		"192.168.1.4",
		"192.168.1.5",
		"192.168.1.6",
		"192.168.1.7",
		"192.168.1.8",
		"192.168.1.9",
	)
	if err != nil {
		t.Error(err)
	}
	fmt.Println(re)
}

// 另外一种实现
import (
	"fmt"
	"github.com/Design-Pattern-Go-Implementation/go-design-pattern/Balancer"
	mrand "math/rand"
	"sync"
	"sync/atomic"
	"time"
)

type randomS struct {
	peers []Balancer.Peer
	count int64
}

// 实现通用的BalancerLite 接口
func (s *randomS) Next(factor Balancer.Factor) (next Balancer.Peer, c Balancer.Constrainable) {
	// 传入的factor实参我们并没有使用
	// 只是随机的产生一个数字
	l := int64(len(s.peers))
	// 取余数得到下标
	// 为什么要给count +随机范围中间的数字？
	ni := atomic.AddInt64(&s.count, inRange(0, l)) % l
	next = s.peers[ni]
	return
}

var seededRand = mrand.New(mrand.NewSource(time.Now().UnixNano()))
var seedmu sync.Mutex

func inRange(min, max int64) int64 {
	seedmu.Lock()
	defer seedmu.Unlock()
	//在某个范围内部生成随机数字，rand.Int（最大值- 最小值）+min
	return seededRand.Int63n(max-min) + min
}

// 实现Peer 接口
type exP string

func (s exP) String() string {
	return string(s)
}

func Random() {

	lb := &randomS{
		peers: []Balancer.Peer{
			exP("172.16.0.7:3500"), exP("172.16.0.8:3500"), exP("172.16.0.9:3500"),
		},
		count: 0,
	}
	// map 用来记录我们实际的后端接口到底被调用了多少次
	sum := make(map[Balancer.Peer]int)
	for i := 0; i < 300; i++ {
		// 这里直接使用默认的实现类的实例
		// DummyFactor 是默认实例
		p, _ := lb.Next(Balancer.DummyFactor)
		sum[p]++
	}

	for k, v := range sum {
		fmt.Printf("%v: %v\n", k, v)
	}

}

// 测试函数
import "testing"

func TestRandom(t *testing.T) {
	Random()
}

// 线程安全实现
//正式的 random LB 的代码要比上面的核心部分还复杂一点点。原因在于我们还需要达成另外两个设计目标：
import (
	"fmt"
	mrand "math/rand"
	"strconv"
	"sync"
	"sync/atomic"
	"time"

	"github.com/Design-Pattern-Go-Implementation/go-design-pattern/Balancer"
)

var seedRand = mrand.New(mrand.NewSource(time.Now().Unix()))
var seedMutex sync.Mutex

func InRange(min, max int64) int64 {
	seedMutex.Lock()
	defer seedMutex.Unlock()
	return seedRand.Int63n(max-min) + min
}

// New 使用 Round-Robin 创建一个新的负载均衡器实例
func New(opts ...Balancer.Opt) Balancer.Balancer {
	return (&randomS{}).Init(opts...)
}

type randomS struct {
	peers []Balancer.Peer
	count int64
	rw    sync.RWMutex
}

func (s *randomS) Init(opts ...Balancer.Opt) *randomS {
	for _, opt := range opts {
		opt(s)
	}
	return s
}

// 实现了Balancer.NexT()方法
func (s *randomS) Next(factor Balancer.Factor) (next Balancer.Peer, c Balancer.Constrainable) {
	next = s.miniNext()

	if fc, ok := factor.(Balancer.FactorComparable); ok {
		next, c, ok = fc.ConstrainedBy(next)
	} else if nested, ok := next.(Balancer.BalancerLite); ok {
		next, c = nested.Next(factor)
	}

	return
}

// 实现了Balancer.Count()方法
func (s *randomS) Count() int {
	s.rw.RLock()
	defer s.rw.RUnlock()
	return len(s.peers)
}

// 实现了Balancer.Add()方法
func (s *randomS) Add(peers ...Balancer.Peer) {
	for _, p := range peers {
		// 判断要添加的元素是否存在，并且在添加元素的时候为s.peers 加锁
		s.AddOne(p)
	}
}

// 实现了Balancer.Remove()方法
// 如果 s.peers 中间有和传入的peer相等的函数就那么就删除这个元素
// 在删除这个元素的时候，
func (s *randomS) Remove(peer Balancer.Peer) {
	// 加写锁
	s.rw.Lock()
	defer s.rw.Unlock()
	for i, p := range s.peers {
		if Balancer.DeepEqual(p, peer) {
			s.peers = append(s.peers[0:i], s.peers[i+1:]...)
			return
		}
	}
}

// 实现了Balancer.Clear()方法
func (s *randomS) Clear() {
	// 加写锁
	// 对于Set() ,Delete(),Update()这类操作就一般都是加写锁
	// 对于Get() 这类操作我们往往是加读锁，阻塞对同一变量的更改操作，但是读操作将不会受到影响
	s.rw.Lock()
	defer s.rw.Unlock()
	s.peers = nil
}

// 我们希望s在返回后端peers 节点的时候，在同一个时刻只能被一个线程拿到。
// 所以需要对 s.peers进行加锁
func (s *randomS) miniNext() (next Balancer.Peer) {
	// 读锁定 写将被阻塞，读不会被锁定
	s.rw.RLock()
	defer s.rw.RUnlock()
	l := int64(len(s.peers))
	ni := atomic.AddInt64(&s.count, InRange(0, l)) % l
	next = s.peers[ni]
	fmt.Printf("s.peers[%d] is be returned\n", ni)
	return
}

func (s *randomS) AddOne(peer Balancer.Peer) {
	if s.find(peer) {
		return
	}
	// 加了写锁
	// 在更改s.peers的时候，其他的线程将不可以调用s.miniNext()读出和获得peer，其他的线程也不可以调用s.AddOne()对s.peers 进行添加操作
	s.rw.Lock()
	defer s.rw.Unlock()
	s.peers = append(s.peers, peer)
	fmt.Printf(peer.String() + "is be appended!\n")
}

func (s *randomS) find(peer Balancer.Peer) (found bool) {
	// 加读锁
	s.rw.RLock()
	defer s.rw.RUnlock()
	for _, p := range s.peers {
		if Balancer.DeepEqual(p, peer) {
			return true
		}
	}
	fmt.Printf("peer in s.peers is be found!\n")
	return
}

func Client() {
	// wg让主进程进行等待我所有的goroutinue 完成
	wg := sync.WaitGroup{}
	// 假设我们有20个不同的客户端（goroutinue）去调用我们的服务
	wg.Add(20)
	lb := &randomS{
		peers: []Balancer.Peer{
			Balancer.ExP("172.16.0.10:3500"), Balancer.ExP("172.16.0.11:3500"), Balancer.ExP("172.16.0.12:3500"),
		},
		count: 0,
	}
	for i := 0; i < 10; i++ {
		go func(t int) {
			lb.Next(Balancer.DummyFactor)
			wg.Done()
			time.Sleep(2 * time.Second)
			// 这句代码第一次运行后，读解锁。
			// 循环到第二个时，读锁定后，这个goroutine就没有阻塞，同时读成功。
		}(i)

		go func(t int) {
			str := "172.16.0." + strconv.Itoa(t) + ":3500"
			lb.Add(Balancer.ExP(str))
			wg.Done()
			// 这句代码让写锁的效果显示出来，写锁定下是需要解锁后才能写的。
			time.Sleep(2 * time.Second)
		}(i)
	}

	time.Sleep(5 * time.Second)
	wg.Wait()
}

// 测试函数
import "testing"

func TestFormal(t *testing.T) {
	Client()
}

// HashKetama 是一个带有 ketama 组合哈希算法的 impl
type HashKetama struct {
	// default is crc32.ChecksumIEEE
	hasher Hasher
	// 负载均衡领域中的一致性 Hash 算法加入了 Replica 因子，计算 Peer 的 hash 值时为 peer 的主机名增加一个索引号的后缀，索引号增量 replica 次
	// 也就是说一个 peer 的 拥有replica 个副本，n 台 peers 的规模扩展为 n x Replica 的规模，有助于进一步提高选取时的平滑度。
	replica int
	// 通过每调用一次Next()函数 ，往hashRing中添加一个计算出的哈希数值
	// 从哈希列表中得到一个哈希值，然后立即得到该哈希值对应的后端的节点
	hashRing []uint32
	// 每个节点都拥有一个属于自己的hash值
	// 每往hashRing 添加一个元素就，就往map中添加一个元素
	keys map[uint32]Balancer.Peer
	// 得到的节点状态是否可用
	peers map[Balancer.Peer]bool
	rw    sync.RWMutex
}

// Hasher 代表可选策略
type Hasher func(data []byte) uint32

//  New 使用 HashKetama 创建一个新的负载均衡器实例
func New(opts ...Balancer.Opt) Balancer.Balancer {

	return (&HashKetama{
		hasher:  crc32.ChecksumIEEE,
		replica: 32,
		keys:    make(map[uint32]Balancer.Peer),
		peers:   make(map[Balancer.Peer]bool),
	}).init(opts...)
}

// 典型的 “把不同参数类型的函数包装成为相同参数类型的函数”

// WithHashFunc allows a custom hash function to be specified.
// The default Hasher hash func is crc32.ChecksumIEEE.
func WithHashFunc(hashFunc Hasher) Balancer.Opt {
	return func(balancer Balancer.Balancer) {
		if l, ok := balancer.(*HashKetama); ok {
			l.hasher = hashFunc
		}
	}
}

// WithReplica allows a custom replica number to be specified.
// The default replica number is 32.
func WithReplica(replica int) Balancer.Opt {
	return func(balancer Balancer.Balancer) {
		if l, ok := balancer.(*HashKetama); ok {
			l.replica = replica
		}
	}
}

// 让 HashKetama 指针穿过一系列的Opt函数
func (s *HashKetama) init(opts ...Balancer.Opt) *HashKetama {
	for _, opt := range opts {
		opt(s)
	}
	return s
}

// Balancer.Factor本质是 string 类型
// 调用Factor()转化为string 类型
// 让 HashKetama实现了Balancer.Balancer接口是一个具体的负载均衡器
// 所有的HashKetama都会接收类型为Balancer.Factor的实例，Balancer.Factor的实例
func (s *HashKetama) Next(factor Balancer.Factor) (next Balancer.Peer, c Balancer.Constrainable) {
	var hash uint32
	// 生成哈希code
	if h, ok := factor.(Balancer.FactorHashable); ok {
		// 如果传入的是具体的实现了Balancer.FactorHashable接口的类
		// 那么肯定实现了具体的HashCode()函数，调用就ok了
		hash = h.HashCode()
	} else {
		// 如果只是传入了实现了父类接口的类的实例
		// 调用hasher 处理父类实例
		// factor.Factor() 把请求"https://abc.local/user/profile"
		hash = s.hasher([]byte(factor.Factor()))
		// s.hasher([]byte(factor.Factor()))本质是 crc32.ChecksumIEEE()函数处理得到的[]byte类型的string
		// 所以重点是crc32.ChecksumIEEE()如何把[]byte转化wei hash code 的
		// 哈希Hash，就是把任意长度的输入，通过散列算法，变换成固定长度的输出，该输出就是散列值。
		// 不定长输入-->哈希函数-->定长的散列值
		// 哈希算法的本质是对原数据的有损压缩
		/* CRC检验原理实际上就是在一个p位二进制数据序列之后附加一个r位二进制检验码(序列)，
		从而构成一个总长为n＝p＋r位的二进制序列；附加在数据序列之后的这个检验码与数据序列的内容之间存在着某种特定的关系。
		如果因干扰等原因使数据序列中的某一位或某些位发生错误，这种特定关系就会被破坏。因此，通过检查这一关系，就可以实现对数据正确性的检验
		注：仅用循环冗余检验 CRC 差错检测技术只能做到无差错接受（只是非常近似的认为是无差错的），并不能保证可靠传输
		*/
	}

	// 根据具体的策略得到下标
	next = s.miniNext(hash)
	if next != nil {
		if fc, ok := factor.(Balancer.FactorComparable); ok {
			next, c, _ = fc.ConstrainedBy(next)
		} else if nested, ok := next.(Balancer.BalancerLite); ok {
			next, c = nested.Next(factor)
		}
	}

	return
}

// 已经有存储着一些哈希数值的切片
// 产生哈希数值
// 在切片中找到大于等于得到的哈希数值的元素
// 该元素作为map的key一定可以找到一个节点

func (s *HashKetama) miniNext(hash uint32) (next Balancer.Peer) {
	s.rw.RLock()
	defer s.rw.RUnlock()
	// 得到的hashcode 去和 hashRing[i]比较
	// sort.Search()二分查找 本质: 找到满足条件的最小的索引
	/*
		//golang 官方的二分写法 (学习一波)

		func Search(n int, f func(int) bool) int {
			// Define f(-1) == false and f(n) == true.
			// Invariant: f(i-1) == false, f(j) == true.
			i, j := 0, n
			for i < j {
				// avoid overflow when computing h
				// 右移一位 相当于除以2
				h := int(uint(i+j) >> 1)
				// i ≤ h < j
				if !f(h) {
					i = h + 1 // preserves f(i-1) == false
				} else {
					j = h // preserves f(j) == true
				}
			}
			// i == j, f(i-1) == false, and f(j) (= f(i)) == true  =>  answer is i.
			return i
		}
	*/

	// 在s.hashRing找到大于等于hash的hashRing的下标
	ix := sort.Search(len(s.hashRing), func(i int) bool {
		return s.hashRing[i] >= hash
	})

	// 当这个下标是最后一个下标时，相当于没有找到
	if ix == len(s.hashRing) {
		ix = 0
	}

	// 如果没有找到就返回s.hashRing的第一个元素
	hashValue := s.hashRing[ix]

	// s.keys 存储 peers 每一个 peers 都有一个hashValue 对应
	// hashcode 对应 hashValue （被Slice存储）
	// hashValue 对应节点 peer  (被Map存储)
	if p, ok := s.keys[hashValue]; ok {
		if _, ok = s.peers[p]; ok {
			next = p
		}
	}

	return
}

/*
在 Add 实现中建立了 hashRing 结构，
它虽然是环形，但是是以数组和下标取模的方式来达成的。
此外，keys 这个 map 解决从 peer 的 hash 值到 peer 的映射关系，今后（在 Next 中）就可以通过从 hashRing 上 pick 出一个 point 之后立即地获得相应的 peer.
在 Next 中主要是在做 factor 的 hash 值计算，计算的结果在 hashRing 上映射为一个点 pt，如果不是恰好有一个 peer 被命中的话，就向后扫描离 pt 最近的 peer。

*/
func (s *HashKetama) Count() int {
	s.rw.RLock()
	defer s.rw.RUnlock()
	return len(s.peers)
}

func (s *HashKetama) Add(peers ...Balancer.Peer) {
	s.rw.Lock()
	defer s.rw.Unlock()

	for _, p := range peers {
		s.peers[p] = true
		for i := 0; i < s.replica; i++ {
			hash := s.hasher(s.peerToBinaryID(p, i))
			s.hashRing = append(s.hashRing, hash)
			s.keys[hash] = p
		}
	}

	sort.Slice(s.hashRing, func(i, j int) bool {
		return s.hashRing[i] < s.hashRing[j]
	})
}

func (s *HashKetama) peerToBinaryID(p Balancer.Peer, replica int) []byte {
	str := fmt.Sprintf("%v-%05d", p, replica)
	return []byte(str)
}

func (s *HashKetama) Remove(peer Balancer.Peer) {
	s.rw.Lock()
	defer s.rw.Unlock()

	if _, ok := s.peers[peer]; ok {
		delete(s.peers, peer)
	}

	var keys []uint32
	var km = make(map[uint32]bool)
	for i, p := range s.keys {
		if p == peer {
			keys = append(keys, i)
			km[i] = true
		}
	}

	for _, key := range keys {
		delete(s.keys, key)
	}

	var vn []uint32
	for _, x := range s.hashRing {
		if _, ok := km[x]; !ok {
			vn = append(vn, x)
		}
	}
	s.hashRing = vn
}

func (s *HashKetama) Clear() {
	s.rw.Lock()
	defer s.rw.Unlock()
	s.hashRing = nil
	s.keys = make(map[uint32]Balancer.Peer)
	s.peers = make(map[Balancer.Peer]bool)
}

func TestHash(t *testing.T) {

	h := int(uint(0+3) >> 1)
	fmt.Print(h)

}

type ConcretePeer string

func (s ConcretePeer) String() string {
	return string(s)
}

var factors = []Balancer.FactorString{
	"https://abc.local/user/profile",
	"https://abc.local/admin/",
	"https://abc.local/shop/item/1",
	"https://abc.local/post/35719",
}

func TestHash1(t *testing.T) {
	lb := New()
	lb.Add(
		ConcretePeer("172.16.0.7:3500"),
		ConcretePeer("172.16.0.8:3500"),
		ConcretePeer("172.16.0.9:3500"),
	)
	// 记录某个节点被调用的次数
	sum := make(map[Balancer.Peer]int)
	// 记录某个具体的节点被哪些ip地址访问过
	hits := make(map[Balancer.Peer]map[Balancer.Factor]bool)
	// 模拟不同时间三个ip 地址对服务端发起多次的请求
	for i := 0; i < 300; i++ {
		// ip 地址依次对服务端发起多次的请求
		factor := factors[i%len(factors)]
		// 把 ip 地址传进去得到具体的节点
		peer, _ := lb.Next(factor)

		sum[peer]++

		if ps, ok := hits[peer]; ok {
			// 判断该ip 地址是否之前访问过该节点
			if _, ok := ps[factor]; !ok {
				// 如果没有访问过则标志为访问过
				ps[factor] = true
			}
		} else {
			// 如过该节点对应的 (访问过该节点的map不存在)证明该节点一次都没有被访问过
			// 那么创建map来 存储该ip地址已经被访问过
			hits[peer] = make(map[Balancer.Factor]bool)
			hits[peer][factor] = true
		}
	}

	// results
	total := 0
	for _, v := range sum {
		total += v
	}

	for p, v := range sum {
		var keys []string
		// p为节点
		for fs := range hits[p] {
			// 打印出每个节点被哪些ip地址访问过
			if kk, ok := fs.(interface{ String() string }); ok {
				keys = append(keys, kk.String())
			} else {
				keys = append(keys, fs.Factor())
			}
		}
		fmt.Printf("%v\nis be invoked %v nums\nis be accessed by these [%v]\n", p, v, strings.Join(keys, ","))
	}

	lb.Clear()
}

func TestHash_M1(t *testing.T) {
	lb := New()
	lb.Add(
		ConcretePeer("172.16.0.7:3500"),
		ConcretePeer("172.16.0.8:3500"),
		ConcretePeer("172.16.0.9:3500"),
	)

	var wg sync.WaitGroup
	var rw sync.RWMutex
	sum := make(map[Balancer.Peer]int)

	const threads = 8
	wg.Add(threads)

	// 这个是最接近业务场景的因为是并发的请求
	for x := 0; x < threads; x++ {
		go func(xi int) {
			defer wg.Done()
			for i := 0; i < 600; i++ {
				p, c := lb.Next(factors[i%3])
				adder(p, c, sum, &rw)
			}
		}(x)
	}
	wg.Wait()
	// results
	for k, v := range sum {
		fmt.Printf("Peer:%v InvokeNum:%v\n", k, v)
	}
}

func TestHash2(t *testing.T) {
	lb := New(
		WithHashFunc(crc32.ChecksumIEEE),
		WithReplica(16),
	)
	lb.Add(
		ConcretePeer("172.16.0.7:3500"),
		ConcretePeer("172.16.0.8:3500"),
		ConcretePeer("172.16.0.9:3500"),
	)
	sum := make(map[Balancer.Peer]int)
	hits := make(map[Balancer.Peer]map[Balancer.Factor]bool)

	for i := 0; i < 300; i++ {
		factor := factors[i%len(factors)]
		peer, _ := lb.Next(factor)

		sum[peer]++
		if ps, ok := hits[peer]; ok {
			if _, ok := ps[factor]; !ok {
				ps[factor] = true
			}
		} else {
			hits[peer] = make(map[Balancer.Factor]bool)
			hits[peer][factor] = true
		}
	}
	lb.Clear()
}

func adder(key Balancer.Peer, c Balancer.Constrainable, sum map[Balancer.Peer]int, rw *sync.RWMutex) {
	rw.Lock()
	defer rw.Unlock()
	sum[key]++
}