hash_consistent

最新推荐文章于 2021-07-29 10:10:17 发布
最新推荐文章于 2021-07-29 10:10:17 发布
阅读量497 收藏
点赞数
分类专栏： program
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/learner811/article/details/27048289
版权 
 
 

  
  
  
  
   
   

    
    hash函数就是把变长的字符转化成定长，是一种压缩映射，hash值空间小于输入空间。hash函数使每个关键字都能均匀分布到hash表，关键字不冲突，常用算法有，直接取余、乘积取整和经典的Times33算法。
   
   

   
   

    
    hash表结构时间复杂度是O(1)，实现方法是创建固定大小数组存数据，设计hash函数，通过hash函数把关键字映射到数组
   
   

   
   

    
    ===========简单hash ============
   
   

   
   

    
    
     
     

      
      <?php
     
     

     
     


     
     

     
     

      
      class 
      
      HashTable
      
      {
     
     

     
     


     
     

     
     
    
      
      private 
      
      $buckets
      
      ;
     
     

     
     


     
     

     
     
    
      
      private 
      
      $size
      
      =
      
      10
      
      ;
     
     

     
     


     
     

     
     
 
     
     

     
     


     
     

     
     
    
      
      public 
      
      function 
      
      __construct
      
      (){
     
     

     
     


     
     

     
     
        
      
      $this
      
      ->
      
      buckets
      
      =
      
      array
      
      ();
      
      //创建一个数组存放数据
     
     

     
     


     
     

     
     
    
      
      }
     
     

     
     


     
     

     
     
    
      
      private 
      
      function 
      
      hashFunc
      
      (
      
      $key
      
      ){
     
     

     
     


     
     

     
     
        
      
      $strlen
      
      =
      
      strlen
      
      (
      
      $key
      
      );
     
     

     
     


     
     

     
     
        
      
      $hashval
      
      =
      
      0
      
      ;
     
     

     
     


     
     

     
     
        
      
      for
      
      (
      
      $i
      
      =
      
      0
      
      ;
      
      $i
      
      <
      
      $strlen
      
      ;
      
      $i
      
      ++
      
      ){
     
     

     
     


     
     

     
     
            
      
      $hashval
      
      +=
      
      ord
      
      (
      
      $key
      
      {
      
      $i
      
      });
      
      //取得$key字符串第$i个字符的ASCII值，然后累加
     
     

     
     


     
     

     
     
        
      
      }
     
     

     
     


     
     

     
     
        
      
      return 
      
      $hashval
      
      %
      
      $this
      
      ->
      
      size
      
      ;
     
     

     
     


     
     

     
     
    
      
      }
     
     

     
     


     
     

     
     
    
      
      //有了hash函数，就可以实现插入和查找，插入数据时先通过hash函数计算关键字所在hash表的位置
     
     

     
     


     
     

     
     
    
      
      //然后把数据保存在此位置即可
     
     

     
     


     
     

     
     
    
      
      public 
      
      function 
      
      insert
      
      (
      
      $key
      
      ,
      
      $value
      
      ){
     
     

     
     


     
     

     
     
        
      
      $index
      
      =
      
      $this
      
      ->
      
      hashFunc
      
      (
      
      $key
      
      );
     
     

     
     


     
     

     
     
        
      
      $this
      
      ->
      
      buckets
      
      [
      
      $index
      
      ]
      
      =
      
      $value
      
      ;
     
     

     
     


     
     

     
     
 
     
     

     
     


     
     

     
     
    
      
      }
     
     

     
     


     
     

     
     
    
      
      //查找数据方法与插入数据类似，先通过hash函数计算关键字所在hash表的位置
     
     

     
     


     
     

     
     
    
      
      //然后返回此位置的数据即可
     
     

     
     


     
     

     
     
    
      
      public 
      
      function 
      
      find
      
      (
      
      $key
      
      ){
     
     

     
     


     
     

     
     
        
      
      $index
      
      =
      
      $this
      
      ->
      
      hashFunc
      
      (
      
      $key
      
      );
     
     

     
     


     
     

     
     
        
      
      return 
      
      $this
      
      ->
      
      buckets
      
      [
      
      $index
      
      ];  
     
     

     
     


     
     

     
     
    
      
      }
     
     

     
     


     
     

     
     

      
      }
     
     

     
     


     
     

     
     

      
      //至此，一个简单的hash表编写完成，下面测试
     
     

     
     


     
     

     
     

      
      $ht
      
      =
      
      new 
      
      HashTable
      
      ();
     
     

     
     


     
     

     
     

      
      $ht
      
      ->
      
      insert
      
      (
      
      'key1'
      
      ,
      
      'value1'
      
      );
      
      //插入key1=>value1
     
     

     
     


     
     

     
     

      
      $ht
      
      ->
      
      insert
      
      (
      
      'key12'
      
      ,
      
      'value12'
      
      );
      
      //插入key2=>value2
     
     

     
     


     
     

     
     

      
      echo 
      
      $ht
      
      ->
      
      find
      
      (
      
      'key1'
      
      ),
      
      "<br />"
      
      ;
      
      //查找key1对应的数据
     
     

     
     


     
     

     
     

      
      echo 
      
      $ht
      
      ->
      
      find
      
      (
      
      'key12'
      
      );
      
      //查找key2对应的数据
     
     

    
    

   
   

   
   

    
    

   
   

   
   

    
    

   
   

   
   

    
    ===========  拉链法  
    
    =========== 
   
   

   
   

    
    <?php
   
   

   
   

    
    //拉链法就是递归存取对象，然后获取值
   
   

   
   
    
    
    class 
    
    HashTable
    
    {
   
   

   
   
        
    
    private 
    
    $bucekts
    
    ;
   
   

   
   
        
    
    private 
    
    $size 
    
    =
    
    10
    
    ;
   
   

   
   
        
   
   

   
   
        
    
    public 
    
    function 
    
    __construct
    
    (){
   
   

   
   
            
    
    $this
    
    ->
    
    buckets 
    
    = 
    
    new 
    
    SplFixedArray
    
    (
    
    $this
    
    ->
    
    size
    
    );
   
   

   
   
        
    
    }
   
   

   
   
        
   
   

   
   
        
    
    private 
    
    function 
    
    hashfunc
    
    (
    
    $key
    
    ){
   
   

   
   
            
    
    $strlen 
    
    = 
    
    strlen
    
    (
    
    $key
    
    );
   
   

   
   
            
    
    $hashval 
    
    = 
    
    0
    
    ;
   
   

   
   
            
    
    for
    
    (
    
    $i
    
    =
    
    0
    
    ;
    
    $i
    
    <
    
    $strlen
    
    ;
    
    $i
    
    ++
    
    {
   
   

   
   
                
    
    $hashval 
    
    += 
    
    ord
    
    (
    
    $key
    
    (
    
    $i
    
    ));
   
   

   
   
            
    
    }
   
   

   
   
            
    
    return 
    
    $hashval 
    
    % 
    
    $this
    
    ->
    
    size
    
    ;
   
   

   
   
        
    
    }
   
   

   
   
        
   
   

   
   
        
    
    public 
    
    function 
    
    insert
    
    (
    
    $key
    
    ,
    
    $val
    
    ){
   
   

   
   
            
    
    $index 
    
    = 
    
    $this
    
    ->
    
    hashfunc
    
    (
    
    $key
    
    );
   
   

   
   
            
    
    $this
    
    ->
    
    buckets
    
    [
    
    $index
    
    ] 
    
    = 
    
    $val
    
    ;
   
   

   
   
        
    
    }
   
   

   
   
        
   
   

   
   
        
    
    public 
    
    function 
    
    find
    
    (
    
    $key
    
    ){
   
   

   
   
            
    
    $index 
    
    = 
    
    $this
    
    ->
    
    hashfunc
    
    (
    
    $key
    
    );
   
   

   
   
            
    
    return 
    
    $this
    
    ->
    
    buckets
    
    [
    
    $index
    
    ];
   
   

   
   
        
    
    }
   
   

   
   
    
    
    }
   
   

   
   
    
    
    ?>
    
    
   
   

   
   

    
        
    
    <?php
   
   

   
   
        
    
    $ht 
    
    = 
    
    new 
    
    HashTable
    
    ();
   
   

   
   
        
    
    $ht
    
    ->
    
    insert
    
    (
    
    'key1'
    
    ,
    
    'value1'
    
    );
   
   

   
   
        
    
    $ht
    
    ->
    
    insert
    
    (
    
    'key1'
    
    ,
    
    'value1'
    
    );
   
   

   
   
        
    
    echo 
    
    $ht
    
    ->
    
    find
    
    (
    
    'key1'
    
    );
   
   

   
   
        
    
    echo 
    
    $ht
    
    ->
    
    find
    
    (
    
    'key2'
    
    );
   
   

   
   
    
   
   

   
   
    
   
   

   
   
    
   
   

   
   
    
    
    拉链法解决
    
    key
    
    值在
    
    hash
    
    上的值重复，就是把相同
    
    hash
    
    值的关键字节点用链表连接起来，比较链表中的每个元素关键字与查找的关键字是否相等
   
   

   
   
    
    
    class 
    
    HashNode
    
    {
   
   

   
   
        
    
    public 
    
    $key
    
    ;
   
   

   
   
        
    
    public 
    
    $value
    
    ;
   
   

   
   
        
    
    public 
    
    $nextNode
    
    ;
   
   

   
   
        
    
    public 
    
    function 
    
    __construct
    
    (
    
    $key
    
    ,
    
    $value
    
    ,
    
    $nextNode 
    
    = 
    
    NULL
    
    ){
   
   

   
   
            
    
    $this
    
    ->
    
    key
    
    =
    
    $key
    
    ;
   
   

   
   
            
    
    $this
    
    ->
    
    value 
    
    =
    
    $value
    
    ;
   
   

   
   
            
    
    $this
    
    ->
    
    nextNode 
    
    = 
    
    $nextNode
    
    ;
   
   

   
   
        
    
    }
   
   

   
   
        
   
   

   
   
        
    
    public 
    
    function 
    
    insert
    
    (
    
    $key
    
    ,
    
    $value
    
    ){
   
   

   
   
            
    
    $index 
    
    = 
    
    $this
    
    ->
    
    hashfunc
    
    (
    
    $key
    
    );
   
   

   
   
            
   
   

   
   
            
    
    if
    
    (
    
    isset
    
    (
    
    $this
    
    ->
    
    buckets
    
    [
    
    $index
    
    ])){
   
   

   
   
                
    
    $newNode 
    
    = 
    
    new 
    
    HashNode
    
    (
    
    $key
    
    ,
    
    $value
    
    ,
    
    $this
    
    ->
    
    buckets
    
    [
    
    $index
    
    ]);
   
   

   
   
            
    
    }
    
    else
    
    {
   
   

   
   
                
    
    $newNode 
    
    = 
    
    new 
    
    HashNode
    
    (
    
    $key
    
    ,
    
    $value
    
    ,
    
    NULL
    
    );
   
   

   
   
            
    
    }
   
   

   
   
            
    
    $this
    
    ->
    
    buckets
    
    [
    
    $index
    
    ] 
    
    = 
    
    $newNode
    
    ;
   
   

   
   
        
    
    }
   
   

   
   
        
   
   

   
   
        
    
    public 
    
    function 
    
    find
    
    (
    
    $key
    
    ){
   
   

   
   
            
    
    $index 
    
    = 
    
    $this
    
    ->
    
    hashfunc
    
    (
    
    $key
    
    );
   
   

   
   
            
    
    $current 
    
    = 
    
    $this
    
    ->
    
    bucekts
    
    [
    
    $index
    
    ];
   
   

   
   
            
    
    while
    
    (
    
    isset
    
    (
    
    $current
    
    )){
   
   

   
   
                
    
    if
    
    (
    
    $curent
    
    ->
    
    key 
    
    == 
    
    $key
    
    ){
   
   

   
   
                    
    
    return 
    
    $current
    
    ->
    
    value
    
    ;
   
   

   
   
                
    
    }
   
   

   
   
                
    
    $current 
    
    = 
    
    $current
    
    ->
    
    nextNode
    
    ;
   
   

   
   
            
    
    }
   
   

   
   
            
    
    return 
    
    NULL
    
    ;
   
   

   
   
        
    
    }
   
   

   
   
    
    
    }
   
   

   
   
    
   
   

   
   
    
    
    ?>
    
    
   
   

   
   

    
        
   
   

   
   

    
        
    
    <?php
   
   

   
   
    
    
    $ht 
    
    = 
    
    new 
    
    HashTable
    
    ();
   
   

   
   
    
    
    $ht
    
    ->
    
    insert
    
    (
    
    'key1'
    
    ,
    
    'value1'
    
    );
   
   

   
   
    
    
    $ht
    
    ->
    
    insert
    
    (
    
    'key12'
    
    ,
    
    'value12'
    
    );
   
   

   
   
    
    
    echo 
    
    $ht
    
    ->
    
    find
    
    (
    
    'key1'
    
    );
   
   

   
   
    
    
    echo 
    
    $ht
    
    ->
    
    find
    
    (
    
    'key12'
    
    );
   
   

   
   

    
         ?>
   
   

   
   

    
    
   
   

   
   

    
    ================ 一致性hash ================
   
   
<?php
 
 

 
 

  
  //逆向映射，也就是key 的hash值大于server 的，然后映射上去
 
 

 
 
    
  
  class 
  
  Flexihash
  
  {
 
 

 
 
        
  
  private  
  
  $serverList 
  
  = 
  
  array
  
  ();
 
 

 
 
        
  
  private 
  
  $isSorted 
  
  = 
  
  FALSE
  
  ;
 
 

 
 

 
 
    
 
 

 
 
    
  
  function 
  
  addServer
  
  (
  
  $server
  
  ){
 
 

 
 
        
  
  $hash 
  
  = 
  
  mHash
  
  (
  
  $server
  
  );
 
 

 
 
        
  
  if
  
  (
  
  !
  
  isset
  
  (
  
  $this
  
  ->
  
  serverList
  
  [
  
  $hash
  
  ])){
 
 

 
 
            
  
  $this
  
  ->
  
  serverList
  
  [
  
  $hash
  
  ] 
  
  = 
  
  $server
  
  ;
 
 

 
 
        
  
  }
 
 

 
 
        
  
  $this
  
  ->
  
  isSorted 
  
  = 
  
  FALSE
  
  ；
 
 

 
 
        
  
  return 
  
  TRUE
  
  ;
 
 

 
 
    
  
  }
 
 

 
 
    
 
 

 
 
    
  
  function 
  
  removeServer
  
  (
  
  $server
  
  ){
 
 

 
 
        
  
  $hash 
  
  = 
  
  mHash
  
  (
  
  $server
  
  );
 
 

 
 
          
  
  if
  
  (
  
  isset
  
  (
  
  $this
  
  ->
  
  serverList
  
  [
  
  $hash
  
  ])){
 
 

 
 
            
  
  unset
  
  (
  
  $this
  
  ->
  
  serverList
  
  [
  
  $hash
  
  ]);
 
 

 
 
        
  
  }
 
 

 
 
        
  
  $this
  
  ->
  
  isSorted 
  
  = 
  
  FALSE
  
  ；
 
 

 
 
        
  
  return 
  
  TRUE
  
  ;
 
 

 
 
    
  
  }
 
 

 
 
    
 
 

 
 
    
  
  function 
  
  lookup 
  
  (
  
  $key
  
  ){
 
 

 
 
        
  
  $hash 
  
  = 
  
  mHash
  
  (
  
  $key
  
  );
 
 

 
 
        
  
  if
  
  (
  
  !
  
  $this
  
  ->
  
  isSorted
  
  ){
 
 

 
 
            
  
  krsort
  
  (
  
  $this
  
  ->
  
  serverList
  
  ,
  
  SORT_NUMERIC
  
  );
 
 

 
 
            
  
  $this
  
  ->
  
  isSorted 
  
  = 
  
  TRUE
  
  ;
 
 

 
 
        
  
  }
 
 

 
 
        
  
  foreach
  
  (
  
  $this
  
  ->
  
  serverList 
  
  as 
  
  $pos
  
  =>
  
  $server
  
  ){
 
 

 
 
            
  
  if
  
  (
  
  $hash 
  
  >= 
  
  $pos
  
  ) 
  
  return 
  
  $server
  
  ;
 
 

 
 
        
  
  }
 
 

 
 
        
 
 

 
 
        
  
  return 
  
  $this
  
  ->
  
  serverList
  
  [
  
  $count
  
  (
  
  $this
  
  ->
  
  serverList
  
  )
  
  -
  
  1
  
  ];
 
 

 
 
    
  
  }
 
 

 
 
    
 
 

 
 
    
  
  function  
  
  mHash
  
  (
  
  $key
  
  ){
 
 

 
 
        
  
  $md5
  
  = 
  
  substr
  
  (
  
  md5
  
  ((
  
  $key
  
  ),
  
  0
  
  ,
  
  8
  
  ));
 
 

 
 
        
  
  $seed 
  
  = 
  
  3
  
  ;
 
 

 
 
        
  
  $hash 
  
  = 
  
  0
  
  ;
 
 

 
 
        
  
  for
  
  (
  
  $i
  
  =
  
  0
  
  ;
  
  $i
  
  <
  
  8
  
  ;
  
  $i
  
  ++
  
  ){
 
 

 
 
            
  
  $hash 
  
  = 
  
  $hash 
  
  * 
  
  $seed
  
  +
  
  ord
  
  (
  
  $md5
  
  (
  
  $i
  
  ));
 
 

 
 
            
  
  $i
  
  ++
  
  ;
 
 

 
 
        
  
  }
 
 

 
 
        
  
  return 
  
  $hash 
  
  & 
  
  0x7FFFFFFF
  
  ;
 
 

 
 
    
  
  }
 
 

 
 
    
  
  }
 
 

 
 
    
 
 

 
 
    
  
  $hserver 
  
  = 
  
  new 
  
  FlexiHash
  
  ();
 
 

 
 
    
  
  $hserver 
  
  -> 
  
  addServer
  
  (
  
  '192.168.1.1'
  
  );
 
 

 
 
    
  
  $hserver 
  
  -> 
  
  addServer
  
  (
  
  '192.168.1.2'
  
  );
 
 

 
 
    
  
  $hserver 
  
  -> 
  
  addServer
  
  (
  
  '192.168.1.3'
  
  );
 
 

 
 
    
  
  $hserver 
  
  -> 
  
  addServer
  
  (
  
  '192.168.1.4'
  
  );
 
 

 
 
    
  
  $hserver 
  
  -> 
  
  addServer
  
  (
  
  '192.168.1.5'
  
  );
 
 

 
 
    
  
  echo 
  
  "save key1 inserver:"
  
  .
  
  $hserver
  
  ->
  
  lookup
  
  (
  
  'key1'
  
  );
 
 

 
 
    
  
  echo 
  
  "save key1 inserver:"
  
  .
  
  $hserver
  
  ->
  
  lookup
  
  (
  
  'key2'
  
  );
 
 

 
 
    
 
 

 
 
    
  
  $hserver
  
  ->
  
  removeServer
  
  (
  
  '192.168.1.4'
  
  );
 
 

 
 
    
  
  echo 
  
  "save key1 inserver:"
  
  .
  
  $hserver
  
  ->
  
  lookup
  
  (
  
  'key1'
  
  );
 
 

 
 
    
  
  echo 
  
  "save key1 inserver:"
  
  .
  
  $hserver
  
  ->
  
  lookup
  
  (
  
  'key2'
  
  );
 
 

 
 
    
 
 

 
 
     
  
  $hserver
  
  ->
  
  removeServer
  
  (
  
  '192.168.1.6'
  
  );
 
 

 
 
    
  
  echo 
  
  "save key1 inserver:"
  
  .
  
  $hserver
  
  ->
  
  lookup
  
  (
  
  'key1'
  
  );
 
 

 
 
    
  
  echo 
  
  "save key1 inserver:"
  
  .
  
  $hserver
  
  ->
  
  lookup
  
  (
  
  'key2'
  
  );
 
 

 
 
    
 
 

 
 
    
  
  $memcached 
  
  = 
  
  new 
  
  Memcached
  
  ((
  
  $serverlist
  
  [
  
  $mash
  
  ]));
 
 

 
 
    
  
  $memcached
  
  ->
  
  set
  
  (
  
  $key
  
  ,
  
  $value
  
  );
telnet166
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
每天进步一点点——五分钟理解一致性哈希算法(consistent hashing)
Cynric 的博客
04-11 48万+
五分钟让你深入了解分布式系统中常用的一致性哈希算法
consistent hash : 一致性hash 简单笔记
taotao 的大学墓志
05-04 518
记得我人生第一次参加面试的时候，面试官问我的就是这样一个问题: 你有很多台服务器，每台服务器上都存放着很多数据，现在要加一台服务器，如何才能让数据搬迁尽可能的少，同时能让每台服务器经可能的负载均衡。现在才发现，这就是可一致性hash 问题，当时我答了个hashMap中的rehash操作，给糊弄过去了… 具体的内容可见 reference，这里大致记录一下 问题定义 简化问题如下: 有 mmm...
linux nginx连接memcache和ngx_http_consistent_hash负载均衡算法
weixin_43947156的博客
01-02 281
一、打开nginx的配置文件 加入这两行配置 1、set memcachedkey"memcached_key "memcachedk​ey"uri"; 2、memcached_pass 127.0.0.1:11211; #memcached的默认端口为11211 3、error_page 404 /callback.php #找不到缓存的时候重定向到callback.php 完整配置如下： 二...
consistent hash(一致性哈希算法)
weixin_34284188的博客
08-05 697
一、产生背景 今天咱不去长篇大论特别详细地讲解consistent hash，我争取用最轻松的方式告诉你consistent hash算法是什么，如果需要深入，Google一下~。 举个栗子吧： 比如有 N 个 cache 服务器，需要将一个object 映射到 N 个 cache 上，我们可以用类似下面的方法计算 object 的 hash 值，然后均...
一致性Hash(Consistent Hashing)原理剖析
一个菜鸟的博客
03-27 1555
https://blog.csdn.net/lihao21/article/details/54193868 引入 在业务开发中，我们常把数据持久化到数据库中。如果需要读取这些数据，除了直接从数据库中读取外，为了减轻数据库的访问压力以及提高访问速度，我们更多地引入缓存来对数据进行存取。读取数据的过程一般为： 图1...
Nginx的负载均衡 - 一致性哈希 (Consistent Hash)
weixin_30510153的博客
12-12 1131
Nginx版本：1.9.1 我的博客：http://blog.csdn.net/zhangskd 算法介绍 当后端是缓存服务器时，经常使用一致性哈希算法来进行负载均衡。 使用一致性哈希的好处在于，增减集群的缓存服务器时，只有少量的缓存会失效，回源量较小。 在nginx+ats / haproxy+squid等CDN架构中，nginx/haproxy所使用的负载均衡算法...
一致性Hash(Consistent Hashing)
qq_42649688的博客
06-17 252
一致性Hash(Consistent Hashing) 一、产生背景 在业务开发中，我们常把数据持久化到数据库中。如果需要读取这些数据，除了直接从数据库中读取外，为了减轻数据库的访问压力以及提高访问速度，我们更多地引入缓存来对数据进行存取。读取数据的过程一般为：先访问缓存，如果缓存存在就从缓存中读取数据，如果缓存不存在就从数据库中读取数据，然后将数据写入缓存 例如有n个服务器，m为机器编号，o为对象名称，我们要将一个对象均匀映射到n个服务器上，采用下面这个式子来定位对象缓存服务器: m = hash(o)
ngx_http_consistent_hash-master.zip
05-21
"ngx_http_consistent_hash-master.zip" 是一个与 Nginx Web服务器相关的压缩包文件，其中包含了一个名为 "ngx_http_consistent_hash" 的第三方模块的源代码。"master" 指示这可能是该模块的主分支或最新版本。 **...
Python库 | jump_consistent_hash-3.1.1-cp27-cp27m-win_amd64.whl
03-31
资源分类：Python库 所属语言：Python 资源全名：jump_consistent_hash-3.1.1-cp27-cp27m-win_amd64.whl 资源来源：官方 安装方法：https://lanzao.blog.csdn.net/article/details/101784059
关于Python3.6无法使用hash_ring库
qq_35225554的博客
02-11 1071
最近在了解推荐系统的相关算法，在学习到一致性hash算法的时候，了解到，Python 已经有人造好轮子了，所以可以直接的使用，在使用的过程中，出现了一些错误，好在错误原因比较简单，解决的比较快，下面是错误解决方案： 如往常一样在linux的已经激活的Python虚拟环境上使用pip安装相关库hash_ring pip install hash_ring 在安装成功后，打开Python，使用...
ConsistentHash:一致性hash算法的 java 和 C++ 实现
05-14
一致性哈希（Consistent Hashing）是一种分布式哈希表（DHT, Distributed Hash Table）算法，主要用于解决在分布式系统中数据存储和检索的问题，尤其是在动态扩展集群节点时，能够尽可能地减少缓存重建，保持系统...
Tars | 第2篇 TarsJava SpingBoot启动与负载均衡源码初探
多氯环己烷的博客
07-29 465
TarsJava SpingBoot启动与负载均衡源码初探前言1. Tars客户端启动@EnableTarsServer2. Communicator通信器3. 客户端的负载均衡调用器LoadBalance最后 前言 通过源码分析可以得出这样一个负载均衡的源码结构图（基于TarsJava SpringBoot）： @EnableTarsServer注解：表明这是一个Tars服务； @Import(TarsServerConfiguration.class)：引入Tars服务相关配置文件； Commu
nginx 一致性hash第三方模块安装方法
Joker
04-08 744
ngx_http_upstream_consistent_hash 模块是一个负载均衡器， 使用一个内部一致性hash算法来选择合适的后端节点。 该模块可以根据配置参数采取不同的方式将请求均匀映射到后端机器， consistent_hash $remote_addr:可以根据客户端ip映射 consistent_hash $request_uri:根据客户端请求的uri映射 consistent_...
consistent Hash （一致性Hash算法）
程序员杂谈
01-14 827
        consistent Hash 的原理是这样的，它将Hash函数的值域空间组织成圆环，假设Hash函数的值域空间为0~232-1（即Hash值是一个32位的无符号整数），整个空间按照顺时针方向进行组织，然后对相应的服务器节点进行Hash，将他们映射到Hash环上，假设有4台服务器，分别为node1，node2，node3，node4， 接下来使用相同的Hash函数，计算出对...
算法游戏
coder
11-07 1172
排序算法：随机法  分治法  贪心法 http://www.cnblogs.com/kkun/archive/2011/11/23/2260312.html 插入排序（根据元素找位置） 冒泡排序（两两比较） 快速排序 （中位数） 选择排序（根据位置找元素） 堆排序（左平衡二叉树） 桶排序（key是值 value是个数，循环获取） 归并算法排序（两两分
算法 review
coder
06-18 742
复杂度           —&gt;区别 数组/链表（单双向）           —&gt;递归（种类）                        —&gt;堆/栈+队列（顺序）/集合（唯一）/哈希表（分布）                        —&gt;二叉树（遍历+平衡+旋转）/图（顶点和边+遍历）数据结构--&gt;复杂度       遍历           -...
经典算法
coder
09-29 389
/*       算法（分类：比较和非比较）：原理 复杂度  稳定性 ==>各自的区别==>代码实现     */      bubble:        相邻比较       On2     稳定的       一步步挪动  quick_sort:    分治法         Onlgn  不稳定的  递归+回归 insert_sort：一趟找到
使用R语言中的Fuzzy C-Means算法对iris数据集进行模糊聚类分析
最新发布
09-03
在这项分析中，我们使用R语言对经典的iris数据集进行了模糊聚类分析，采用了Fuzzy C-Means（FCM）算法。Fuzzy C-Means是一种改进的聚类算法，允许每个数据点以不同的隶属度（概率）属于多个簇，而不仅仅是硬性分配到单个簇。这种方法特别适用于数据点之间界限不清晰的情况，通过计算每个数据点到各个簇中心的距离来确定其隶属度，从而生成更灵活的聚类结果。 在该分析中，我们首先从iris数据集中提取了四个数值变量——花萼长度、花萼宽度、花瓣长度和花瓣宽度。接着，我们加载了R中的cluster包，并使用其中的fanny函数执行Fuzzy C-Means聚类。我们设定了聚类数为3，这是因为iris数据集中的物种数为3个，虽然我们事先知道这些类别，但我们通过算法进行盲分类，以便验证其效果。 fanny函数的一个重要特点是其模糊指数参数（memb.exp），该参数决定了隶属度的模糊性。设置为较高的数值会使聚类结果更加模糊，即数据点可能较均匀地分布在多个簇中；而较低的数值则使得聚类结果更接近传统的硬聚类。
consistenthash java
01-14
ConsistentHash是一种在分布式系统中解决数据分片、负载均衡的算法，用于解决数据分布和节点动态变化的问题。在Java中，可以通过实现ConsistentHash算法来分配数据并达到负载均衡的效果。 在Java中，可以使用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值