一致性哈希算法
- 📖1. 普通哈希算法存在的问题
- 📖2. 一致性哈希算法概念
- 📖3. 代码实现
📖1. 普通哈希算法存在的问题
在介绍一致性哈希算法前，我们先来看两个场景：
场景一：
现在，假如有三个用户的请求，即三个ip地址，需要被负载均衡到这三台服务器上去，并且，我们使用这样的哈希算法，能够保证同一个客户端永远被映射到一台指定的server上，这样可以有效解决会话共享问题.
简单来说，就是比如现在我们来了一个用户请求，假如它叫张三，并被负载均衡到2号服务器上，那么2号服务器就保存了他的登录状态信息，但是如果下一次张三发出请求，他又被映射到了一号服务器上，但一号服务器上没有保存有关张三的会话信息，那么1号服务器怎么知道张三的登录状态呢？又怎么正确的对张三的请求做出处理呢？
所以，我们是需要让同一客户端每次被映射到一台指定的server上.
假如，现在有张三、李四、王五三个客户端，他们每次都被映射到一台指定的server上，现在，如果3号服务器突然挂掉：
场景二：
例如，服务端需要增删查看数据，如果服务端直接去数据库中查找，效率太低，所以我们需要将一些热点数据先缓存起来，以便下次查找时提高效率，假设现在我们以用户id作为key，用户信息作为value，如果第一次去查找时没找到，那就去数据库中查找，然后再将此次的查找结果保存在缓存中，以便以后再次查找时快速读取，如果找到，那么服务端直接从缓存中拿到数据并处理，并最终返回给客户端.
所以，综合上述的两个场景可以看出，普通的哈希算法是存在许多问题的，所以我们需要引入一致性哈希算法.
📖2. 一致性哈希算法概念
一致性哈希算法是分布式系统负载均衡的首选算法.
服务器负载均衡环境下，可以配置的负载均衡算法有很多种，比如：轮询算法，哈希算法，权重比算法，最少连接算法.
一个良好的分布式哈希方案应该具有良好的单调性，即服务器节点的增减不会造成大量哈希的重定位.
什么是一致性哈希算法？
那么还有一个问题：服务器经过一致性哈希处理之后，在哈希环上应该分散一些好，还是集中在一起好？
这种问题也叫哈希环的倾斜.
所以，在一致性哈希算法中，就采用了虚拟节点来解决这个问题：
即对每一台服务器节点计算多个哈希，每个计算结果位置都放置一个此服务节点，称作虚拟节点. 一个实际的物理节点可以对应多个虚拟节点，虚拟节点越多，哈希环上的节点就越多，缓存/客户端被均匀分布的概率就越大，哈希环倾斜所带来的影响就越小，同时数据定位算法不变，只是多了一步虚拟节点到实际节点的映射.
落在A1，A2，A3，A4上的节点，均负载到A服务器上，落在B1，B2，B3，B4上的节点，均负载到B服务器上.
📖3. 代码实现
#include<iostream>
#include<string>
#include<list>
#include<set>
#include<map>
#include"md5.h"
using namespace std;
using uint = unsigned int;
class PhysicalHost;
//虚拟节点
class VirtualHost
{
public:
VirtualHost(string ip, PhysicalHost* p)
: ip_(ip)
, physicalHost_(p)
{
//md5算法，用来将ip地址离散到哈希环上
// 把32位的md5串，处理成unsigned int返回
//unsigned int getMD5(const char* buf);
md5_ = getMD5(ip_.c_str());
}
bool operator<(const VirtualHost& vhost) const
{
return md5_ < vhost.md5_;
}
bool operator==(const VirtualHost& vhost) const
{
return vhost.ip_ == ip_;
}
const PhysicalHost* getPhysicalHost() const
{
return physicalHost_;
}
uint getmd5() const
{
return md5_;
}
private:
string ip_; //虚拟节点的ip信息
uint md5_; //虚拟节点在哈希环上的位置
PhysicalHost* physicalHost_; //该虚拟节点所对应的物理节点
};
//物理节点
class PhysicalHost
{
public:
PhysicalHost(string ip, int vnumber)
:ip_(ip)
{
//添加虚拟节点
for (int i = 0; i < vnumber; ++i)
{
virtualHosts_.emplace_back(ip_ + "#" + to_string(i), this);
}
}
string getIP() const
{
return ip_;
}
const list<VirtualHost>& getVirtualHosts() const
{
return virtualHosts_;
}
private:
string ip_; //物理机器的ip地址
list<VirtualHost> virtualHosts_; // 存储物理节点对应的虚拟节点列表
};
//一致性哈希算法实现
class ConsistentHash
{
public:
//在一致性哈希环上添加物理主机的虚拟节点
void addHost(const PhysicalHost& host)
{
//获取物理主机的所有虚拟节点列表
auto list = host.getVirtualHosts();
for (auto vhost : list)
{
hashCircle_.insert(vhost);
}
}
//在一致性哈希环上删除物理主机的虚拟节点
void delHost(PhysicalHost& host)
{
auto list = host.getVirtualHosts();
for (auto host : list)
{
auto it = hashCircle_.find(host);
if (it != hashCircle_.end())
{
hashCircle_.erase(it);
}
}
}
//返回负载的真实物理主机的ip信息
string getHost(string clientip) const
{
uint md5 = getMD5(clientip.c_str());
for (auto vhost : hashCircle_)
{
if (vhost.getmd5() > md5)
{
return vhost.getPhysicalHost()->getIP();
}
}
return hashCircle_.begin()->getPhysicalHost()->getIP();
}
private:
set<VirtualHost> hashCircle_; //一致性哈希环
};
void ShowConsistentHash(ConsistentHash& chash)
{
list<string> iplists ={
"192.168.1.123",
"192.168.1.12",
"192.168.1.13",
"192.168.1.23",
"192.168.1.54",
"192.168.1.89",
"192.168.1.21",
"192.168.1.27",
"192.168.1.49",
"192.168.1.145",
"192.168.2.34",
"192.168.6.78",
"192.168.2.90",
"192.168.4.5"
};
map<string, list<string>> logMap;
for (auto client : iplists)
{
string host = chash.getHost(client);
logMap[host].emplace_back(client);
}
for (auto pair : logMap)
{
cout << "物理主机：" << pair.first << endl;
cout << "负载客户端的数量：" << pair.second.size() << endl;
for (auto ip : pair.second)
{
cout << ip << endl;
}
cout << "------------------------" << endl;
}
cout << endl;
}
int main()
{
PhysicalHost host1("10.117.124.10", 150);
PhysicalHost host2("10.117.124.20", 150);
PhysicalHost host3("10.117.124.30", 150);
//在一致性哈希环上添加三台物理主机
ConsistentHash chash;
chash.addHost(host1);
chash.addHost(host2);
chash.addHost(host3);
ShowConsistentHash(chash);
//host1挂掉
chash.delHost(host1);
ShowConsistentHash(chash);
return 0;
}
