引入
在业务开发中，我们常把数据持久化到数据库中。如果需要读取这些数据，除了直接从数据库中读取外，为了减轻数据库的访问压力以及提高访问速度，我们更多地引入缓存来对数据进行存取。读取数据的过程一般为：

图1：加入缓存的数据读取过程
对于分布式缓存，不同机器上存储不同对象的数据。为了实现这些缓存机器的负载均衡，可以使用式子1来定位对象缓存的存储机器：

m = hash(o) mod n ——式子1

其中，o为对象的名称，n为机器的数量，m为机器的编号，hash为一hash函数。图2中的负载均衡器（load balancer）正是使用式子1来将客户端对不同对象的请求分派到不同的机器上执行，例如，对于对象o，经过式子1的计算，得到m的值为3，那么所有对对象o的读取和存储的请求都被发往机器3执行。

图2：如何利用Hash取模实现负载均衡
式子1在大部分时候都可以工作得很好，然而，当机器需要扩容或者机器出现宕机的情况下，事情就比较棘手了。
当机器扩容，需要增加一台缓存机器时，负载均衡器使用的式子变成：

m = hash(o) mod (n + 1) ——式子2

当机器宕机，机器数量减少一台时，负载均衡器使用的式子变成：

m = hash(o) mod (n - 1) ——式子3
我们以机器扩容的情况为例，说明简单的取模方法会导致什么问题。假设机器由3台变成4台，对象o1由式子1计算得到的m值为2，由式子2计算得到的m值却可能为0，1，2，3（一个 3t + 2的整数对4取模，其值可能为0，1，2，3，读者可以自行验证），大约有75%（3/4)的可能性出现缓存访问不命中的现象。随着机器集群规模的扩大，这个比例线性上升。当99台机器再加入1台机器时，不命中的概率是99%（99/100）。这样的结果显然是不能接受的，因为这会导致数据库访问的压力陡增，严重情况，还可能导致数据库宕机。

一致性hash算法正是为了解决此类问题的方法，它可以保证当机器增加或者减少时，对缓存访问命中的概率影响减至很小。下面我们来详细说一下一致性hash算法的具体过程。
一致性Hash环
一致性hash算法通过一个叫作一致性hash环的数据结构实现。这个环的起点是0，终点是2^32 - 1，并且起点与终点连接，环的中间的整数按逆时针分布，故这个环的整数分布范围是[0, 2^32-1]，如下图3所示：

图3：一致性Hash环
将对象放置到Hash环
假设现在我们有4个对象，分别为o1，o2，o3，o4，使用hash函数计算这4个对象的hash值（范围为0 ~ 2^32-1）:

hash(o1) = m1
hash(o2) = m2
hash(o3) = m3
hash(o4) = m4

把m1，m2，m3，m4这4个值放置到hash环上，得到如下图4：

图4：放置了对象的一致性Hash环

将机器放置到Hash环
使用同样的hash函数，我们将机器也放置到hash环上。假设我们有三台缓存机器，分别为 c1，c2，c3，使用hash函数计算这3台机器的hash值：

hash(c1) = t1
hash(c2) = t2
hash(c3) = t3

把t1，t2，t3 这3个值放置到hash环上，得到如下图5：

图5：放置了机器的一致性Hash环
为对象选择机器
将对象和机器都放置到同一个hash环后，在hash环上顺时针查找距离这个对象的hash值最近的机器，即是这个对象所属的机器。
例如，对于对象o2，顺序针找到最近的机器是c1，故机器c1会缓存对象o2。而机器c2则缓存o3，o4，机器c3则缓存对象o1。

图6：在一致性Hash环上为对象选择机器

处理机器增减的情况
对于线上的业务，增加或者减少一台机器的部署是常有的事情。
例如，增加机器c4的部署并将机器c4加入到hash环的机器c3与c2之间。这时，只有机器c3与c4之间的对象需要重新分配新的机器。对于我们的例子，只有对象o4被重新分配到了c4，其他对象仍在原有机器上。如图7所示：

图7：增加机器后的一致性Hash环的结构

如上文前面所述，使用简单的求模方法，当新添加机器后会导致大部分缓存失效的情况，使用一致性hash算法后这种情况则会得到大大的改善。前面提到3台机器变成4台机器后，缓存命中率只有25%（不命中率75%）。而使用一致性hash算法，理想情况下缓存命中率则有75%，而且，随着机器规模的增加，命中率会进一步提高，99台机器增加一台后，命中率达到99%，这大大减轻了增加缓存机器带来的数据库访问的压力。

再例如，将机器c1下线（当然，也有可能是机器c1宕机），这时，只有原有被分配到机器c1对象需要被重新分配到新的机器。对于我们的例子，只有对象o2被重新分配到机器c3，其他对象仍在原有机器上。如图8所示：

图8：减少机器后的一致性Hash环的结构

虚拟节点
上面提到的过程基本上就是一致性hash的基本原理了，不过还有一个小小的问题。新加入的机器c4只分担了机器c2的负载，机器c1与c3的负载并没有因为机器c4的加入而减少负载压力。如果4台机器的性能是一样的，那么这种结果并不是我们想要的。
为此，我们引入虚拟节点来解决负载不均衡的问题。
将每台物理机器虚拟为一组虚拟机器，将虚拟机器放置到hash环上，如果需要确定对象的机器，先确定对象的虚拟机器，再由虚拟机器确定物理机器。
说得有点复杂，其实过程也很简单。

还是使用上面的例子，假如开始时存在缓存机器c1，c2，c3，对于每个缓存机器，都有3个虚拟节点对应，其一致性hash环结构如图9所示：

图9：机器c1，c2，c3的一致性Hash环结构

假设对于对象o1，其对应的虚拟节点为c11，而虚拟节点c11对象缓存机器c1，故对象o1被分配到机器c1中。

新加入缓存机器c4，其对应的虚拟节点为c41，c42，c43，将这三个虚拟节点添加到hash环中，得到的hash环结构如图10所示：

图10：机器c1，c2，c3，c4的一致性Hash环结构

新加入的缓存机器c4对应一组虚拟节点c41，c42，c43，加入到hash环后，影响的虚拟节点包括c31，c22，c11（顺时针查找到第一个节点），而这3个虚拟节点分别对应机器c3，c2，c1。即新加入的一台机器，同时影响到原有的3台机器。理想情况下，新加入的机器平等地分担了原有机器的负载，这正是虚拟节点带来的好处。而且新加入机器c4后，只影响25%（1/4）对象分配，也就是说，命中率仍然有75%，这跟没有使用虚拟节点的一致性hash算法得到的结果是相同的。

总结
一致性hash算法解决了分布式环境下机器增加或者减少时，简单的取模运算无法获取较高命中率的问题。通过虚拟节点的使用，一致性hash算法可以均匀分担机器的负载，使得这一算法更具现实的意义。正因如此，一致性hash算法被广泛应用于分布式系统中。

参考资料
https://en.wikipedia.org/wiki/Consistent_hashing

https://www.codeproject.com/articles/56138/consistent-hashing

《大型网站技术架构——核心原理与安全分析》，李智慧著，电子工业出版社

作者：haozlee
来源：CSDN
原文：https://blog.csdn.net/lihao21/article/details/54193868
版权声明：本文为博主原创文章，转载请附上博文链接！
一致性hash算法的PHP实现

<?php
/**

• Flexihash - A simple consistent hashing implementation for PHP.
• The MIT License
• Copyright (c) 2008 Paul Annesley
• Permission is hereby granted, free of charge, to any person obtaining a copy
• of this software and associated documentation files (the "Software"), to deal
• in the Software without restriction, including without limitation the rights
• to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
• copies of the Software, and to permit persons to whom the Software is
• furnished to do so, subject to the following conditions:
• The above copyright notice and this permission notice shall be included in
• all copies or substantial portions of the Software.
• THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
• IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
• FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
• AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
• LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
• OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
• THE SOFTWARE.
• @author Paul Annesley
• @link http://paul.annesley.cc/
• @copyright Paul Annesley, 2008
• @comment by MyZ (http://blog.csdn.net/mayongzhan)
  */

/**

• A simple consistent hashing implementation with pluggable hash algorithms.
• @author Paul Annesley
• @package Flexihash

• @licence http://www.opensource.org/licenses/mit-license.php
  */
  class Flexihash
  {
  /**

  • The number of positions to hash each target to.
  • @var int
  • @comment 虚拟节点数,解决节点分布不均的问题
    */
    private $_replicas = 64;

  /**

  • The hash algorithm, encapsulated in a Flexihash_Hasher implementation.
  • @var object Flexihash_Hasher
  • @comment 使用的hash方法 : md5,crc32
    */
    private $_hasher;

  /**

  • Internal counter for current number of targets.
  • @var int
  • @comment 节点记数器
    */
    private $_targetCount = 0;

  /**

  • Internal map of positions (hash outputs) to targets
  • @var array { position => target, ... }
  • @comment 位置对应节点,用于lookup中根据位置确定要访问的节点
    */
    private $_positionToTarget = array();

  /**

  • Internal map of targets to lists of positions that target is hashed to.
  • @var array { target => [ position, position, ... ], ... }
  • @comment 节点对应位置,用于删除节点
    */
    private $_targetToPositions = array();

  /**

  • Whether the internal map of positions to targets is already sorted.
  • @var boolean
  • @comment 是否已排序
    */
    private $_positionToTargetSorted = false;

  /**

  • Constructor
  • @param object $hasher Flexihash_Hasher
  • @param int $replicas Amount of positions to hash each target to.
  • @comment 构造函数,确定要使用的hash方法和需拟节点数,虚拟节点数越多,分布越均匀,但程序的分布式运算越慢
    */
    public function __construct(Flexihash_Hasher $hasher = null, $replicas = null)
    {
    $this->_hasher = $hasher ? $hasher : new Flexihash_Crc32Hasher();
    if (!empty($replicas)) $this->_replicas = $replicas;
    }

  /**

  • Add a target.
  • @param string $target
  • @chainable

  • @comment 添加节点,根据虚拟节点数,将节点分布到多个虚拟位置上
    */
    public function addTarget($target)
    {
    if (isset($this->_targetToPositions[$target]))
    {
    throw new Flexihash_Exception("Target '$target' already exists.");
    }

    $this->_targetToPositions[$target] = array();

    // hash the target into multiple positions
    for ($i = 0; $i < $this->_replicas; $i++)
    {
    $position = $this->_hasher->hash($target . $i);
    $this->_positionToTarget[$position] = $target; // lookup
    $this->_targetToPositions[$target] []= $position; // target removal
    }

    $this->_positionToTargetSorted = false;
    $this->_targetCount++;

    return $this;
    }

  /**

  • Add a list of targets.
  • @param array $targets

  • @chainable
    */
    public function addTargets($targets)
    {
    foreach ($targets as $target)
    {
    $this->addTarget($target);
    }

    return $this;
    }

  /**

  • Remove a target.
  • @param string $target

  • @chainable
    */
    public function removeTarget($target)
    {
    if (!isset($this->_targetToPositions[$target]))
    {
    throw new Flexihash_Exception("Target '$target' does not exist.");
    }

    foreach ($this->_targetToPositions[$target] as $position)
    {
    unset($this->_positionToTarget[$position]);
    }

    unset($this->_targetToPositions[$target]);

    $this->_targetCount--;

    return $this;
    }

  /**

  • A list of all potential targets
  • @return array
    */
    public function getAllTargets()
    {
    return array_keys($this->_targetToPositions);
    }

  /**

  • A list of all potential targets
  • @return array
    */
    public function getAll()
    {
    return array(
    "targers"=>$this->_positionToTarget,
    "positions"=>$this->_targetToPositions);
    }

  /**

  • Looks up the target for the given resource.
  • @param string $resource
  • @return string
    */
    public function lookup($resource)
    {
    $targets = $this->lookupList($resource, 1);
    if (empty($targets)) throw new Flexihash_Exception('No targets exist');
    return $targets[0]; //0表示返回离资源位置最近的机器节点
    }

  /**

  • Get a list of targets for the resource, in order of precedence.
  • Up to $requestedCount targets are returned, less if there are fewer in total.
  • @param string $resource
  • @param int $requestedCount The length of the list to return
  • @return array List of targets
  • @comment 查找当前的资源对应的节点,
  • 节点为空则返回空,节点只有一个则返回该节点,
  • 对当前资源进行hash,对所有的位置进行排序,在有序的位置列上寻找当前资源的位置
  • 当全部没有找到的时候,将资源的位置确定为有序位置的第一个(形成一个环)

  • 返回所找到的节点
    */
    public function lookupList($resource, $requestedCount)
    {
    if (!$requestedCount)
    throw new Flexihash_Exception('Invalid count requested');

    // handle no targets
    if (empty($this->_positionToTarget))
    return array();

    // optimize single target
    if ($this->_targetCount == 1)
    return array_unique(array_values($this->_positionToTarget));

    // hash resource to a position
    $resourcePosition = $this->_hasher->hash($resource);

    $results = array();
    $collect = false;

    $this->_sortPositionTargets();

    // search values above the resourcePosition
    foreach ($this->_positionToTarget as $key => $value)
    {
    // start collecting targets after passing resource position
    if (!$collect && $key > $resourcePosition)
    {
    $collect = true;
    }

    // only collect the first instance of any target
    if ($collect && !in_array($value, $results))
    {$results []= $value;//var_dump($results);
    }
    // return when enough results, or list exhausted
    //var_dump(count($results));
    //var_dump($requestedCount);
    if (count($results) == $requestedCount || count($results) == $this->_targetCount)
    {return $results;
    }

    }

    // loop to start - search values below the resourcePosition
    foreach ($this->_positionToTarget as $key => $value)
    {
    if (!in_array($value, $results))
    {
    $results []= $value;
    }

    // return when enough results, or list exhausted
    if (count($results) == $requestedCount || count($results) == $this->_targetCount)
    {return $results;
    }

    }

    // return results after iterating through both "parts"
    return $results;
    }

  public function __toString()
  {
  return sprintf(
  '%s{targets:[%s]}',
  get_class($this),
  implode(',', $this->getAllTargets())
  );
  }

  // ----------------------------------------
  // private methods

  /**

  • Sorts the internal mapping (positions to targets) by position
    */
    private function _sortPositionTargets()
    {
    // sort by key (position) if not already
    if (!$this->_positionToTargetSorted)
    {
    ksort($this->_positionToTarget, SORT_REGULAR);
    $this->_positionToTargetSorted = true;
    }
    }

}

/**

• Hashes given values into a sortable fixed size address space.
• @author Paul Annesley
• @package Flexihash

• @licence http://www.opensource.org/licenses/mit-license.php
  */
  interface Flexihash_Hasher
  {

  /**

  • Hashes the given string into a 32bit address space.
  • Note that the output may be more than 32bits of raw data, for example
  • hexidecimal characters representing a 32bit value.
  • The data must have 0xFFFFFFFF possible values, and be sortable by
  • PHP sort functions using SORT_REGULAR.
  • @param string
  • @return mixed A sortable format with 0xFFFFFFFF possible values
    */
    public function hash($string);

}

/**

• Uses CRC32 to hash a value into a signed 32bit int address space.
• Under 32bit PHP this (safely) overflows into negatives ints.
• @author Paul Annesley
• @package Flexihash

• @licence http://www.opensource.org/licenses/mit-license.php
  */
  class Flexihash_Crc32Hasher
  implements Flexihash_Hasher
  {

  /* (non-phpdoc)

  • @see Flexihash_Hasher::hash()
    */
    public function hash($string)
    {
    return crc32($string);
    }

}

/**

• Uses CRC32 to hash a value into a 32bit binary string data address space.
• @author Paul Annesley
• @package Flexihash

• @licence http://www.opensource.org/licenses/mit-license.php
  */
  class Flexihash_Md5Hasher
  implements Flexihash_Hasher
  {

  /* (non-phpdoc)

  • @see Flexihash_Hasher::hash()
    */
    public function hash($string)
    {
    return substr(md5($string), 0, 8); // 8 hexits = 32bit

    // 4 bytes of binary md5 data could also be used, but
    // performance seems to be the same.
    }

}

/**

• An exception thrown by Flexihash.
• @author Paul Annesley
• @package Flexihash
• @licence http://www.opensource.org/licenses/mit-license.php
  */
  class Flexihash_Exception extends Exception
  {
  }
  复制代码
  测试代码

复制代码
$hash = new Flexihash();
$targets=array(
"192.168.1.1:11011",
"192.168.1.1:11012",
"192.168.1.1:11013",
"192.168.1.1:11014",
"192.168.1.1:11015",
);
$hash->addTargets($targets);
for ($i=0; $i < 25; $i++) {
$resource = sprintf("format %d",$i);
var_dump($resource." --> ".$hash->lookup($resource));
}
输出

复制代码
string(30) "format 0 --> 192.168.1.1:11015"
string(30) "format 1 --> 192.168.1.1:11015"
string(30) "format 2 --> 192.168.1.1:11015"
string(30) "format 3 --> 192.168.1.1:11015"
string(30) "format 4 --> 192.168.1.1:11011"
string(30) "format 5 --> 192.168.1.1:11011"
string(30) "format 6 --> 192.168.1.1:11011"
string(30) "format 7 --> 192.168.1.1:11011"
string(30) "format 8 --> 192.168.1.1:11012"
string(30) "format 9 --> 192.168.1.1:11013"
string(31) "format 10 --> 192.168.1.1:11013"
string(31) "format 11 --> 192.168.1.1:11011"
string(31) "format 12 --> 192.168.1.1:11012"
string(31) "format 13 --> 192.168.1.1:11011"
string(31) "format 14 --> 192.168.1.1:11014"
string(31) "format 15 --> 192.168.1.1:11014"
string(31) "format 16 --> 192.168.1.1:11014"
string(31) "format 17 --> 192.168.1.1:11014"
string(31) "format 18 --> 192.168.1.1:11012"
string(31) "format 19 --> 192.168.1.1:11012"
string(31) "format 20 --> 192.168.1.1:11013"
string(31) "format 21 --> 192.168.1.1:11012"
string(31) "format 22 --> 192.168.1.1:11012"
string(31) "format 23 --> 192.168.1.1:11014"
string(31) "format 24 --> 192.168.1.1:11012"
[Finished in 0.1s]
复制代码
redis分布式代码设计

<?php
require_once("Flexihash.php");
$config=array(
"127.0.0.1:6371",
"127.0.0.1:6372",
"127.0.0.1:6373",
"127.0.0.1:6374",
);
class RedisCollect {
//redis实例
private $_redis = null;
//hash实例
private $_hash = null;
//初始化
public function __construct() {
global $config;
$this->_redis = new Redis();
$this->_hash = new Flexihash();
$this->_hash->addTargets($config);
}
public function set($key="", $value="") {
$m = $this->switchConncetion($key);
return $m->set($key, $value);
}
public function get($key) {
$m = $this->switchConncetion($key);
return $m->get($key);
}
private function switchConncetion($key) {
$hostinfo = $this->_hash->lookup($key);
$m = $this->connect($hostinfo);
return $m;
}
private function connect($hostinfo) {
list($host, $port) = explode(":", $hostinfo);
//printf("host = %s, port = %s\n",$host,$port);
if(empty($host) || empty($port)) {
return false;
}
try {
$this->_redis->connect($host, $port);
return $this->_redis;
} catch(Exception $e) {
die($e->getMessage());
}
}
}