Memcached 一致性hash分布式算法

<?php

    interface HashWay{
        public function hash($string);
    }

    class Md5HashWay implements HashWay{
        public function hash($string){
            return md5($string,0,8);
        }
    }

    class Crc32HashWay implements HashWay{
        public function hash($string){
            return crc32($string);
        }
    }

    class HashException extends Exception{

    }

    class ConsistentHash{
        //每一台memcached服务器的虚拟节点个数
        private $_replicas = 64;
        //表示memcached服务器的数量
        private $_targetCount = 0;
        //虚拟节点散列用到的hash算法
        private $_hasher = null;
        //一台memcached服务器对应的虚拟节点
        private $_targetToPostion = array();
        //虚拟节点对应memcached
        private $_postionToTarget = array();
        //是否排序
        private $_postionToTargetSorted = false;


        //构造函数，确定hasher的方法，已经虚拟节点的个数
        public function __construct(HashWay $hash = null,$replicas = null){
            $this->_hasher = $hash ? $hash : new Crc32HashWay();
            if(!empty($replicas))$this->_replicas = intval($replicas);
        }

        //增加一台服务器的操作
        public function addTarget($target){
            if(isset($this->targetToPostion[$target])){throw new HashException("$target exists");}
            
            //如果这台服务器没有存在，则给这台服务器去生成虚拟节点
            for($i = 0 ; $i < $this->_replicas; $i++){
                $postion = $this->_hasher->hash($target.$i);
                //虚拟节点指向target
                $this->_postionToTarget[$postion] = $target;
                //每一个服务器对应的虚拟节点
                $this->_targetToPostion[$target][] = $postion;
            }

            $this->_targetCount++;

            //每次增加memcached服务器过来，虚拟节点都会混乱，必须排序来解决问题
            $this->_postToTargetSorted = false;
            return $this;
        }

        //增加多台memcached服务器
        public function addTargets($targets){
            if(is_array($targets) && !empty($targets)){
                foreach ($targets as $key => $value) {
                    $this->addTarget($value);
                }
            }
        }

        //删除一台服务器的操作
        public function removeTarget($target){
            if(!isset($this->_targetToPostion[$target])){throw new HashException("$target not exists");}
        
            //现在进行删除服务器的操作
            foreach ($this->_targetToPostion[$target] as $key => $value) {
                //根据虚拟节点数组，来删除指向target的数组
                if(isset($this->_postionToTarget[$value])){
                    unset($this->_postionToTarget[$value]);
                }
            }
            unset($this->_targetToPostion[$target]);
            $this->_targetCount--;
            return $this;
        }


        //得到全部的memcached服务器
        public function getAllTargets(){
            return array_keys($this->_targetToPostion);
        }

        //查找存储的服务器
        public function lookUp($resource){
            $result = $this->lookUpList($resource);
            return $this->_postionToTarget[current($result)];
        }
        
        //lookup函数返回一个环，数组0表示的是顺时针最近的memcached服务器
        public function lookUpList($resource){

            if($this->_targetCount == 0){
                return array();
            }

            //如果只有一个服务器，则返回
            if($this->_targetCount == 1){
                return array_unique(array_values($this->_postionToTarget));
            }
            

            //如果没有找到一个服务器
            //1对虚拟节点进行排序
            $this->_sortedPostToTargets();


            //2对查找的resource进行hash
            $hashresource = $this->_hasher->hash($resource);

            //3对虚拟节点查找
            $flag = false;
            $result = array();

            //4优先查找服务器，取得顺时针最近的服务器
            foreach ($this->_postionToTarget as $key => $value) {
                if(!$flag && $key > $hashresource){
                    $flag = true;
                }

                if($flag == true && !in_array($key,$result)){
                    $result[] = $key;
                }

                if(count($result) == $this->_targetCount){
                    return $result;
                }
            }

            //5如果没有在顺时针取得服务器，那就重新再来一遍
            foreach ($this->_postionToTarget as $key => $value) {
                if(!in_array($key,$result)){
                    $result[] = $key;
                }

                if(count($result) == $this->_targetCount){
                    return $result;
                }
            }

            return $result;
        }

        //对虚拟节点进行排序
        private function _sortedPostToTargets(){
            if(!$this->_postionToTargetSorted){
                ksort($this->_postionToTarget,SORT_REGULAR);
                $this->_postionToTargetSorted = true;
            }
        }
    }
    
    
    $a = new ConsistentHash;
    //添加了两台主机
    $a->addTarget('192.168.1.1')->addTarget('192.168.1.2')->addTarget('192.168.1.3')->addTarget('192.168.1.4');
    print_r($a->getAllTargets());
    
    echo "<br/>";
    $result = array();
    for($i = 0; $i < 100 ; $i++){
        if(!isset($result[$a->lookUp($i)])){
            $result[$a->lookUp($i)] = 1;
        }else{
            $result[$a->lookUp($i)] ++;
        }
    }
    
    print_r($result);
    
?>
Array ( [0] => 192.168.1.1 [1] => 192.168.1.2 [2] => 192.168.1.3 [3] => 192.168.1.4 ) 
Array ( [192.168.1.2] => 13 [192.168.1.1] => 44 [192.168.1.3] => 28 [192.168.1.4] => 15 )

　　这边只是简单的代码实现，用于解决分布均衡问题

学习地址：http://blog.csdn.net/cywosp/article/details/23397179

　　　　　http://blog.sina.com.cn/s/blog_3fde8252010147j5.html

　　　　　好像忘记添加一个链接了，有原代码一致性hash的链接，我就是看懂，然后自己写了下，不喜勿喷。