一致性Hash算法（转载）
原文地址http://blog.csdn.net/caigen1988/article/details/7708806
consistent hashing 算法早在 1997 年就在论文 Consistent hashing and random trees 中被提出，目前在 cache 系统中应用越来越广泛；
2 由于访问加重，需要添加 cache ，这时候 cache 是 N+1 台，映射公式变成了 hash(object)%(N+1) ；
1 和 2 意味着什么？这意味着突然之间几乎所有的 cache 都失效了。对于服务器而言，这是一场灾难，洪水般的访问都会直接冲向后台服务器；
再来考虑第三个问题，由于硬件能力越来越强，你可能想让后面添加的节点多做点活，显然上面的 hash 算法也做不到。
有什么方法可以改变这个状况呢，这就是 consistent hashing...
Hash 算法的一个衡量指标是单调性（ Monotonicity ），定义如下：
单调性是指如果已经有一些内容通过哈希分派到了相应的缓冲中，又有新的缓冲加入到系统中。哈希的结果应能够保证原有已分配的内容可以被映射到新的缓冲中去，而不会被映射到旧的缓冲集合中的其他缓冲区。
容易看到，上面的简单 hash 算法 hash(object)%N 难以满足单调性要求。
consistent hashing 是一种 hash 算法，简单的说，在移除 / 添加一个 cache 时，它能够尽可能小的改变已存在 key 映射关系，尽可能的满足单调性的要求。
下面就来按照 5 个步骤简单讲讲 consistent hashing 算法的基本原理。
接下来考虑 4 个对象 object1~object4 ，通过 hash 函数计算出的 hash 值 key 在环上的分布如图 2 所示。
Consistent hashing 的基本思想就是将对象和 cache 都映射到同一个 hash 数值空间中，并且使用相同的hash 算法。
假设当前有 A,B 和 C 共 3 台 cache ，那么其映射结果将如图 3 所示，他们在 hash 空间中，以对应的 hash值排列。
说到这里，顺便提一下 cache 的 hash 计算，一般的方法可以使用 cache 机器的 IP 地址或者机器名作为hash 输入。
现在 cache 和对象都已经通过同一个 hash 算法映射到 hash 数值空间中了，接下来要考虑的就是如何将对象映射到 cache 上面了。
因此这里仅需要变动对象 object4 ，将其重新映射到 cache C 上即可；参见图 4 。
因此这里仅需要变动对象 object2 ，将其重新映射到 cache D 上；参见图 5 。
考量 Hash 算法的另一个指标是平衡性 (Balance) ，定义如下：
平衡性是指哈希的结果能够尽可能分布到所有的缓冲中去，这样可以使得所有的缓冲空间都得到利用。
为了解决这种情况， consistent hashing 引入了"虚拟节点"的概念，它可以如下定义：
objec1->cache A2 ； objec2->cache A1 ； objec3->cache C1 ； objec4->cache C2 ；
因此对象 object1 和 object2 都被映射到了 cache A 上，而 object3 和 object4 映射到了 cache C 上；平衡性有了很大提高。
引入"虚拟节点"后，映射关系就从 { 对象 -> 节点 } 转换到了 { 对象 -> 虚拟节点 } 。查询物体所在 cache时的映射关系如图 7 所示。
"虚拟节点"的 hash 计算可以采用对应节点的 IP 地址加数字后缀的方式。例如假设 cache A 的 IP 地址为202.168.14.241 。
引入"虚拟节点"前，计算 cache A 的 hash 值：
引入"虚拟节点"后，计算"虚拟节"点 cache A1 和 cache A2 的 hash 值：
Hash("202.168.14.241#1"); // cache A1
Hash("202.168.14.241#2"); // cache A2
这就要由hash算法来保证了，均匀分布是概率上的均匀，当虚拟节点足够时，就能保证大概均匀了。
2.假如cache通过hash函数计算出的值和 object通过hash函数计算出来的值是同一个hash值怎么办？
那object应该指向哪个cache?
C++实现方法：转自：http://www.cnblogs.com/coser/archive/2011/11/27/2265134.html
一致性hash算法实现有两个关键问题需要解决，一个是用于结点存储和查找的数据结构的选择，另一个是结点hash算法的选择。
笔者用C++语言对一致性hash算法进行了实现，下面我将会描述下一些关键细节。
1、首先定义实体结点类、虚拟结点类。一个实体结点对应多个虚拟结点。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 | /*实体结点*/ class CNode_s { public: /*构造函数*/ CNode_s(); CNode_s(char * pIden , int pVNodeCount , void * pData);
/*获取结点标示*/ const char * getIden();
/*获取实体结点的虚拟结点数量*/ int getVNodeCount();
/*设置实体结点数据值*/ void setData(void * data);
/*获取实体结点数据值*/ void * getData(); private: void setCNode_s(char * pIden, int pVNodeCount , void * pData); char iden[100];/*结点标示串*/ int vNodeCount;/*虚拟结点数目*/ void * data;/*数据结点*/ }; |
虚拟结点 CVirtualNode_s：虚拟结点有一指针指向实体结点
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 | /*虚拟结点*/ class CVirtualNode_s { public: /*构造函数*/ CVirtualNode_s(); CVirtualNode_s(CNode_s * pNode);
/*设置虚拟结点所指向的实体结点*/ void setNode_s(CNode_s * pNode);
/*获取虚拟结点所指向的实体结点*/ CNode_s * getNode_s();
/*设置虚拟结点hash值*/ void setHash(long pHash);
/*获取虚拟结点hash值*/ long getHash(); private: long hash;/*hash值*/ CNode_s * node; /*虚拟结点所指向的实体结点*/ }; |
2、hash算法具有可选择性，定义一个hash算法接口，方便以后进行其他算法的扩展。
这里创建MD5hash类，并继承该接口，通过MD5算法求hash值。
类图：
CHashFun接口：
1 2 3 4 5 6 7 | /*定义Hash函数类接口，用于计算结点的hash值*/
class CHashFun { public: virtual long getHashVal(const char *) = 0; }; |
CMD5HashFun 类继承CHashFun接口，实现获取hash值的getHashVal函数：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 | /*用MD5算法计算结点的hash值，继承CHashFun父类*/ class CMD5HashFun : public CHashFun { public: virtual long getHashVal (const char * ); };
long CMD5HashFun::getHashVal(const char * instr) { int i; long hash = 0; unsignedchar digest[16];
/*调用MD5相关函数，生成instr的MD5码，存入digest*/ md5_state_t md5state; md5_init(&md5state); md5_append(&md5state, (const unsignedchar *)instr,strlen(instr)); md5_finish(&md5state, digest);
/* 每四个字节构成一个32位整数， 将四个32位整数相加得到instr的hash值（可能溢出） */ for(i = 0; i < 4; i++) { hash += ((long)(digest[i*4 + 3]&0xFF) << 24) | ((long)(digest[i*4 + 2]&0xFF) << 16) | ((long)(digest[i*4 + 1]&0xFF) << 8) | ((long)(digest[i*4 + 0]&0xFF)); } return hash; } |
3、扩展红黑树结构中的查找函数，用于查找红黑树中大于key值中最小的结点。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 | util_rbtree_node_t* util_rbtree_lookup(util_rbtree_t *rbtree, long key) { if((rbtree != NULL) && !util_rbtree_isempty(rbtree)) { util_rbtree_node_t *node = NULL; util_rbtree_node_t *temp = rbtree->root; util_rbtree_node_t *null = _NULL(rbtree); while(temp != null) { if(key <= temp->key) { node = temp; /* update node */ temp = temp->left; } else if(key > temp->key) { temp = temp->right; } } /* if node==NULL return the minimum node */ return ((node != NULL) ? node : util_rbtree_min(rbtree)); } return NULL; } |
4、创建一致性hash类。使其具有插入、删除、查找实体结点的功能。
具体算法和操作过程已经在代码注释中说明。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 | class CConHash { public: /*构造函数*/ CConHash(CHashFun * pFunc);
/*设置hash函数*/ void setFunc(CHashFun * pFunc);
/*增加实体结点 , 0代表成功 , -1代表失败*/ int addNode_s(CNode_s * pNode);
/*删除实体结点 , 0代表成功 , -1代表失败*/ int delNode_s(CNode_s * pNode);
/*查找实体结点*/ CNode_s * lookupNode_s(const char * object);
/*获取一致性hash结构的所有虚拟结点数量*/ int getVNodes(); private: /*Hash函数*/ CHashFun * func; /*虚拟结点总个数*/ int vNodes; /*存储虚拟结点的红黑树*/ util_rbtree_t * vnode_tree; }; /*辅助函数，虚拟结点转化为红黑树结点*/ util_rbtree_node_t * vNode2RBNode(CVirtualNode_s * vnode);
CConHash::CConHash(CHashFun * pFunc) { /*设置hash函数*/ assert(pFunc!=NULL); this->func = pFunc; this->vNodes = 0; /*初始化红黑树*/ vnode_tree = new util_rbtree_s(); util_rbtree_init(vnode_tree); }
int CConHash::addNode_s(CNode_s * pNode) { if(pNode==NULL)return -1; int vCount = pNode->getVNodeCount(); if(vCount<=0)return -1; CVirtualNode_s * virtualNode ; util_rbtree_node_t * rbNode; char str [100]; char num[10]; strcpy(str,pNode->getIden()); long hash = 0; /*生成虚拟结点并插入到红黑树中*/ for(int i=0;i<vCount;i++) { virtualNode = new CVirtualNode_s(pNode); /*采用str+"i"的方法产生不同的iden串，用于后面的hash值计算*/ itoa(i,num,10); strcat(str,num); hash = func->getHashVal(str); virtualNode->setHash(hash); if(!util_rbtree_search(vnode_tree,hash)) { /*生成红黑树结点*/ rbNode = vNode2RBNode(virtualNode); if(rbNode!=NULL) { /*将该结点插入到红黑树中*/ util_rbtree_insert(vnode_tree,rbNode); this->vNodes++; } } } return 0; }
int CConHash::delNode_s(CNode_s * pNode) { if(pNode==NULL)return -1; util_rbtree_node_t * rbNode; char str [100]; char num [10]; strcpy(str,pNode->getIden()); int vCount = pNode->getVNodeCount(); long hash = 0; CVirtualNode_s * node = NULL; /*将该实体结点产生的所有虚拟结点进行删除*/ for(int i=0;i<vCount;i++) { itoa(i,num,10); strcat(str,num);/*采用该方法产生不同的iden串*/ hash = func->getHashVal(str); rbNode = util_rbtree_search(vnode_tree,hash); if(rbNode!=NULL) { node = (CVirtualNode_s *) rbNode->data; if(node->getNode_s()==pNode && node->getHash()==hash) { this->vNodes--; /*将该结点从红黑树中删除*/ util_rbtree_delete(vnode_tree,rbNode); delete rbNode; delete node; } } } return 0; }
CNode_s * CConHash::lookupNode_s(const char * object) { if(object==NULL||this->vNodes==0)return NULL; util_rbtree_node_t * rbNode; int key = this->func->getHashVal(object); /*在红黑树中查找key值比key大的最小的结点*/ rbNode = util_rbtree_lookup(vnode_tree,key); if(rbNode!=NULL) { return ((CVirtualNode_s *) rbNode->data)->getNode_s(); } return NULL; }
int CConHash::getVNodes() { return this->vNodes; }
util_rbtree_node_t * vNode2RBNode(CVirtualNode_s * vnode) { if(vnode==NULL)return NULL; util_rbtree_node_t *rbNode = new util_rbtree_node_t(); rbNode->key = vnode->getHash(); rbNode->data = vnode; return rbNode; } |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 | #include<iostream> #include"CNode_s.h" #include"CVirtualNode_s.h" #include"CHashFun.h" #include"CMD5HashFun.h" #include"CConHash.h" #include<string.h> #include<time.h>
using namespace std;
void getIP(char * IP) { int a=0, b=0 , c=0 , d=0; a = rand()%256; b = rand()%256; c = rand()%256; d = rand()%256; char aa[4],bb[4],cc[4],dd[4]; itoa(a, aa, 10); itoa(b, bb, 10); itoa(c, cc, 10); itoa(d, dd, 10); strcpy(IP,aa); strcat(IP,"."); strcat(IP,bb); strcat(IP,"."); strcat(IP,cc); strcat(IP,"."); strcat(IP,dd); }
int main() { srand(time(0)); freopen("out.txt","r",stdin); /*定义hash函数*/ CHashFun * func = new CMD5HashFun(); /*创建一致性hash对象*/ CConHash * conhash = new CConHash(func);
/*定义CNode*/ CNode_s * node1 = new CNode_s("machineA",50,"10.3.0.201"); CNode_s * node2 = new CNode_s("machineB",80,"10.3.0.202"); CNode_s * node3 = new CNode_s("machineC",20,"10.3.0.203"); CNode_s * node4 = new CNode_s("machineD",100,"10.3.0.204");
conhash->addNode_s(node1); conhash->addNode_s(node2); conhash->addNode_s(node3); conhash->addNode_s(node4);
/*动态更改结点数据值*/ // node1->setData("99999999");
int ans1 ,ans2 ,ans3 ,ans4; ans1=ans2=ans3=ans4=0;
char object[100]; CNode_s * node ; /*动态删除结点*/ //conhash->delNode_s(node2); for(int i =0;i<30;i++) { // getIP(object); // cout<<object<<endl; cin>>object; node = conhash->lookupNode_s(object); if(node!=NULL) { cout<<object<<"----->\t"<<node->getIden()<<" \t "<<(char *)node->getData()<<endl; if(strcmp(node->getIden(),"machineA")==0) ans1++; if(strcmp(node->getIden(),"machineB")==0) ans2++; if(strcmp(node->getIden(),"machineC")==0) ans3++; if(strcmp(node->getIden(),"machineD")==0) ans4++; } }
cout<<"Total test cases : "<<ans1+ans2+ans3+ans4<<endl; cout<<"Map to MachineA : "<<ans1<<endl; cout<<"Map to MachineB : "<<ans2<<endl; cout<<"Map to MachineC : "<<ans3<<endl; cout<<"Map to MachineD : "<<ans4<<endl; fclose(stdin); return 0; } |
6、删除结点对hash路由的影响测试
测试结果截图：
分析：上面两幅图，左边为原始四个实体结点的路由情况，后面为删除结点2（Node2）之后的路由情况。不难发现，MachineB down之后，原先的路由请求，较均衡地负载到了其他机器结点，而且对原先路由到其他结点的请求没有影响。比如139.149.184.125这个请求仍会路由到MachineD，并不会因为结点的减少而造成影响。但是，如果是增加实体结点，可能会造成增加前后路由情况不一致的现象，因为路由区间的更加狭小，但是不会有特别大的影响。 另一方面，可以发现实体结点的虚拟结点个数比例分配情况很大程度影响了结点的负载路由情况，比例大致与虚拟结点个数相一致。
总结：
本文首先通过介绍实现一致性hash算法的关键算法和数据结构的选择分析，选择了红黑树作为虚拟结点的存储结构，以及MD5算法作为Hash函数用于计算结点的hash值。并使用C++语言，对一致性hash算法进行了实现，实现了一致性hash实体结点的增加、删除、查找等基本功能，并进行了测试分析。由于笔者水平有限，存在很多有待改进的地方，因此本文仅供大家参考、讨论学习。
项目源代码下载：https://files.cnblogs.com/coser/ConsistentHashAlgorithm.rar
