AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

Hash一致性闭环算法 - ( 适用于Redis扩容、Nginx多级缓存 等等 )

2022-11-15 187
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
Redis 开源版，标准版 2GB
推荐场景：
搭建游戏排行榜
云数据库 Tair（兼容Redis），内存型 2GB
推荐场景：
通过缓存加速数据库访问
简介： Hash一致性闭环算法 - ( 适用于Redis扩容、Nginx多级缓存 等等 )模拟Redis扩容做的Hash一致性闭环算法

模拟Redis扩容做的Hash一致性闭环算法

前置条件

Java语言 采用Map 模拟Redis环境

适用场景

Redis扩容采用Hash闭环、Nginx多级缓存采用Hash闭环+Lua手动负载器 等等其他需要做扩容的方案

一致性hash解决的问题

分布式缓存中如果使用简单hash，节点增加和减少对于系统影响非常大。而一致性hash则高效地解决了这个问题。一致性hash不是说节点增加和减少完全没有影响，而是相比简单hash大大降低了这个影响。

一致性hash算法

一致性hash算法也是通过hash取模，只不过取模的值不再是节点个数这样一个可变的量，而是一个相对而言比较大的不变值，例如int型最大值。我们将0和int型最大值首尾相连这样就形成了一个闭环，我们称其为hash环

如果当前有某个节点宕机，那么受影响的数据，只是当前那一个区间的数据

只需要将这一个区间内的数据 重新

源码

import org.apache.commons.lang3.StringUtils;
import java.util.*;
import java.util.regex.Pattern;
/**
 * Created Date by 2019/12/27 0027.
 * 模拟 一致性hash算法 前半部分 redis 分布区域选择
 * 这里用随机数代替hash
 *
 * @author Parker
 */
public class TestHash {
    private static String default2 = "default2";
/** 生成所有指令 */
    private static Map<String, Map<String, String>> instructions = new HashMap<>();
/**上下文指令 */
    private static Stack<String> contextKeys = new Stack<>();
/**上下文指令 */
    private static Stack<String> instructionKeys = new Stack<>();
/** redis 集合 */
    private static Map<Integer, String> redisMap = new TreeMap<>(new Comparator<Integer>() {
        @Override
public int compare(Integer o1, Integer o2) {
return o1.compareTo(o2);
        }
    });
/** redis 仓库 */
    private static Map<String, List<Integer>> redisRepository = new HashMap<>();
/**
     * 静态块
     */
    static{
        contextKeys.add("system");
        instructions = TestHash.createInstructions();
        // 添加三台redis服务器 在一个闭环
        TestHash.createRedisMap("xxoo1-redis",1456);
        TestHash.createRedisMap("xxoo2-redis",5437);
        TestHash.createRedisMap("xxoo3-redis",8524);
        // 初始化数据
        TestHash.addNum(1000);
        TestHash.addNum(2000);
        TestHash.addNum(5000);
        TestHash.addNum(6000);
        TestHash.addNum(7000);
        TestHash.addNum(8000);
        TestHash.addNum(10000);
        TestHash.addNum(15000);
        TestHash.addNum(20000);
        TestHash.addNum(25000);
        TestHash.addNum(40000);
    }
public static void main(String[] args) {
System.out.println("欢迎使用 redis一致性hash算法 模拟系统 ！");
System.out.println();
        // 输入检测
        TestHash.invokeScanner(contextKeys,null,false);
    }
/**
     * 生成Redis 仓库
     *
     * 生成仓库 则 锁定类 这里用 synchronized 代替
     * ☆☆☆☆☆☆☆☆☆☆☆☆☆
     *  现实环境中 需要￿做分布式锁 避免在迁移数据过程中 又有新的数据 做改动 ****** ☆
     * @return
     */
public synchronized static void createRedisMap(String redisCode,Integer num) {
Set<Integer> integers = redisMap.keySet();
        Iterator<Integer> iterator = integers.iterator();
        List<Integer> keys = new ArrayList<>(integers.size());
while (iterator.hasNext()){
            keys.add(iterator.next());
        }
        //正序
        keys.sort(new Comparator<Integer>() {
            @Override
public int compare(Integer o1, Integer o2) {
return o1.compareTo(o2);
            }
        });
        // 调用闭环算法
Integer key = null;
if(keys != null && !keys.isEmpty()){
            key = TestHash.closedLoopAlgorithm(num,keys);
        }
        // 根据 闭环算法 获得数据
        List<Integer> datas = null;
if(null != key){
            datas = redisRepository.get(redisMap.get(key));
        }
        // 创建集合
        List<Integer> list = new ArrayList<>();
        redisRepository.put(redisCode,list);
        redisMap.put(num,redisCode);
        // 因为上方有新增redis 获取 新的 keys
        integers = redisMap.keySet();
        iterator = integers.iterator();
        List<Integer> keysT = new ArrayList<>(integers.size());
while (iterator.hasNext()){
            keysT.add(iterator.next());
        }
        // 数据迁移
if(datas != null && !datas.isEmpty()){
            List<Integer> newDatas = new ArrayList<>();
            // 循环所有数据 查找出 要存放在新容器里的数据
for (Integer data : datas) {
                // 调用闭环算法
Integer keyT = TestHash.closedLoopAlgorithm(data,keysT);
if(keyT.equals(num)){
                    newDatas.add(data);
                }
            }
            // 删除 旧数据
for (Integer newData : newDatas) {
                // 传入keys 因为 keys已做更改 传入旧keys
                TestHash.deleteOldData(newData,keys);
            }
            // 添加新数据
            List<Integer> newQueue = redisRepository.get(redisMap.get(num));
for (Integer newData : newDatas) {
                newQueue.add(newData);
            }
        }
    }
/**
     * 生成Redis 数据
     * @return
     */
public static void addNum(Integer num) {
Integer key = 0;
Set<Integer> integers = redisMap.keySet();
        Iterator<Integer> iterator = integers.iterator();
        List<Integer> keys = new ArrayList<>(integers.size());
while (iterator.hasNext()){
            keys.add(iterator.next());
        }
        //正序
        keys.sort(new Comparator<Integer>() {
            @Override
public int compare(Integer o1, Integer o2) {
return o1.compareTo(o2);
            }
        });
        // 调用闭环算法
        key = TestHash.closedLoopAlgorithm(num,keys);
        List<Integer> datas = redisRepository.get(redisMap.get(key));
        datas.add(num);
        List<Integer> nums = new ArrayList<>();
for (Integer integer : keys) {
if(redisRepository.get(redisMap.get(integer)) != null){
                nums.addAll(redisRepository.get(redisMap.get(integer)));
            }
        }
System.out.println();
System.out.println("当前数据：");
System.out.println(nums.toString());
for (Integer integer : keys) {
if(redisRepository.get(redisMap.get(integer)) != null){
System.out.println(redisMap.get(integer)+":"+redisRepository.get(redisMap.get(integer)).toString());
            }
        }
System.out.println();
    }
/**
     * 查看Redis 所有数据
     * @return
     */
public static void findAll() {
Set<Integer> integers = redisMap.keySet();
        Iterator<Integer> iterator = integers.iterator();
        List<Integer> keys = new ArrayList<>(integers.size());
while (iterator.hasNext()){
            keys.add(iterator.next());
        }
        //正序
        keys.sort(new Comparator<Integer>() {
            @Override
public int compare(Integer o1, Integer o2) {
return o1.compareTo(o2);
            }
        });
        List<Integer> nums = new ArrayList<>();
for (Integer integer : keys) {
if(redisRepository.get(redisMap.get(integer)) != null){
                nums.addAll(redisRepository.get(redisMap.get(integer)));
            }
        }
System.out.println();
System.out.println("当前数据：");
System.out.println(nums.toString());
for (Integer integer : keys) {
if(redisRepository.get(redisMap.get(integer)) != null){
System.out.println(redisMap.get(integer)+":"+redisRepository.get(redisMap.get(integer)).toString());
            }
        }
System.out.println();
    }
/**
     * 删除Redis数据
     * @return
     */
public static void deleteData(Integer num) {
Integer key = 0;
Set<Integer> integers = redisMap.keySet();
        Iterator<Integer> iterator = integers.iterator();
        List<Integer> keys = new ArrayList<>(integers.size());
while (iterator.hasNext()){
            keys.add(iterator.next());
        }
        //正序
        keys.sort(new Comparator<Integer>() {
            @Override
public int compare(Integer o1, Integer o2) {
return o1.compareTo(o2);
            }
        });
        // 调用闭环算法
        key = TestHash.closedLoopAlgorithm(num,keys);
        List<Integer> datas = redisRepository.get(redisMap.get(key));
boolean deFlag = false;
int count = 0;
for (int i = 0; i < datas.size(); i++) {
if(num.equals(datas.get(i))){
                deFlag = true;
                count = i;
                break;
            }
        }
if(deFlag){
            datas.remove(count);
        }
        List<Integer> nums = new ArrayList<>();
for (Integer integer : keys) {
if(redisRepository.get(redisMap.get(integer)) != null){
                nums.addAll(redisRepository.get(redisMap.get(integer)));
            }
        }
System.out.println();
System.out.println("当前数据：");
System.out.println(nums.toString());
for (Integer integer : keys) {
if(redisRepository.get(redisMap.get(integer)) != null){
System.out.println(redisMap.get(integer)+":"+redisRepository.get(redisMap.get(integer)).toString());
            }
        }
System.out.println();
    }
/**
     * 删除Redis数据
     * @return
     */
public synchronized static void deleteOldData(Integer num,List<Integer> keys) {
Integer key = 0;
        //正序
        keys.sort(new Comparator<Integer>() {
            @Override
public int compare(Integer o1, Integer o2) {
return o1.compareTo(o2);
            }
        });
        // 调用闭环算法
        key = TestHash.closedLoopAlgorithm(num,keys);
        List<Integer> datas = redisRepository.get(redisMap.get(key));
boolean deFlag = false;
int count = 0;
for (int i = 0; i < datas.size(); i++) {
if(num.equals(datas.get(i))){
                deFlag = true;
                count = i;
                break;
            }
        }
if(deFlag){
            datas.remove(count);
        }
        List<Integer> nums = new ArrayList<>();
for (Integer integer : keys) {
if(redisRepository.get(redisMap.get(integer)) != null){
                nums.addAll(redisRepository.get(redisMap.get(integer)));
            }
        }
    }
/**
     * 闭环算法 核心算法
     * ☆☆☆☆☆☆☆☆☆☆
     * @param num
     * @param keys
     * @return
     */
public static Integer closedLoopAlgorithm(Integer num,List<Integer> keys){
Integer key = 0;
if(num > keys.get(keys.size()-1) || num <= keys.get(0)){
    key = keys.get(0);
  }else {
    for (int i = keys.size() - 2; i >= 0; i--) {
      if(num > keys.get(i)){
        key = keys.get(i+1);
        break;
      }
    }
  }
return key;
    }
/**
     * 下方代码 是输入 相关 与 一致性算法无关
     */
/*-----------------------------------------------------------------------------------------------------------------------------------------------*/
/**
     * 创建随机数
     * @param
     */
public static int createRandom(){
        // 最大数
Integer max = 10000;
return new Random().nextInt(max);
    }
/**
     * 输入方案
     */
public static void invokeScanner(Stack<String> contextKey,String instruction,boolean errorF){
        try{
            String key = contextKey.peek();
            String[] keys = key.split("_");
            List<String> keyList = Arrays.asList(keys);
            // 如果输入错误 进行排查
boolean errorFlag = true;
if(errorF && keyList.size() > 1){
                List<String> tempList = new ArrayList<>();
for (int i = 0; i < keyList.size()-1; i++) {
                    tempList.add(keyList.get(i));
                }
                keyList = tempList;
                errorFlag = false;
            }
            // 顶级
if("system".equals(keys[0])){
                // 一级
if(keyList.size() == 1){
if(errorFlag){
                        contextKey.add(contextKey.peek()+"_top");
                    }
                    instruction = TestHash.validataScanner(instructions.get(TestHash.createInstructionKey()));
                    // 验证指令输入
                    String instructionKeyTemp = null;
if(instructionKeys.size() > 0){
                        instructionKeyTemp = instructionKeys.peek();
                    }
                    TestHash.invokeScanner(contextKey,instructionKeyTemp,false);
                }else{
                    // 一级
if("top".equals(keyList.get(1))){
                        // 查询当前所有redis集群
if("1".equals(instruction)){
if(errorFlag){
                                contextKey.add(contextKey.peek()+"_getRedis");
                            }
                            // 打印当前 redis 服务器数量
                            TestHash.printRedis(redisMap);
                            // 发起二次输入
                            // 验证指令输入
if(errorFlag){
                                contextKey.add(contextKey.peek()+"_back");
                            }
                            instruction = TestHash.validataScanner(instructions.get(default2));
                            TestHash.invokeScanner(contextKey,instruction,false);
                        }
                        // 增加redis集群
else if("2".equals(instruction)){
if(errorFlag){
                                contextKey.add(contextKey.peek()+"_addRedis");
                            }
                            String code = "";
Integer num = 0;
System.out.println();
System.out.println("------------------------------");
System.out.println("请输入redis编号：");
boolean fl = true;
while (fl){
                                // 开启输入模式
                                Scanner scanner = new Scanner(System.in);
                                String str = scanner.nextLine();
                                String pattern = "[\\w\\d]+";
boolean matches = Pattern.matches(pattern, str);
if(matches){
                                    List<Integer> integers = redisRepository.get(str);
if(integers != null){
System.out.println("------------------------------");
System.out.println();
System.out.println("[ "+str+" ] 编号已存在");
System.out.println();
System.out.println("请输入redis编号：");
System.out.println();
continue;
                                    }
                                    code = str;
                                    fl = false;
                                }else{
System.out.println("------------------------------");
System.out.println();
System.out.println("[ "+str+" ] 只能包含字母、数字与_");
System.out.println();
System.out.println("请输入redis编号：");
System.out.println();
                                }
                            }
System.out.println();
System.out.println("------------------------------");
System.out.println("请输入redis数据范围：");
boolean fl1 = true;
while (fl1){
                                // 开启输入模式
                                Scanner scanner = new Scanner(System.in);
                                String str = scanner.nextLine();
                                String pattern = "[\\d]+";
boolean matches = Pattern.matches(pattern, str);
if(matches){
                                    num = Integer.parseInt(str);
                                    String s = redisMap.get(num);
if(!StringUtils.isEmpty(s)){
System.out.println("------------------------------");
System.out.println();
System.out.println("[ "+str+" ] 数据范围已存在");
System.out.println();
System.out.println("请输入redis数据范围：");
System.out.println();
continue;
                                    }
                                    fl1 = false;
                                }else{
System.out.println("------------------------------");
System.out.println();
System.out.println("[ "+str+" ] 只能包含数字");
System.out.println();
System.out.println("请输入redis数据范围：");
System.out.println();
                                }
                            }
                            TestHash.createRedisMap(code,num);
                            // 打印当前 redis 服务器数量
                            TestHash.printRedis(redisMap);
                            // 发起二次输入
                            // 验证指令输入
if(errorFlag){
                                contextKey.add(contextKey.peek()+"_add");
                            }
                            instruction = TestHash.validataScanner(instructions.get(default2));
                            TestHash.invokeScanner(contextKey,instruction,false);
                        }
                        // 增加redis数据
else if("3".equals(instruction)){
if(errorFlag){
                                contextKey.add(contextKey.peek()+"_addRedisData");
                            }
System.out.println();
System.out.println("------------------------------");
System.out.println("请输入数值：");
Integer num = 0;
boolean fl = true;
while (fl){
                                // 开启输入模式
                                Scanner scanner = new Scanner(System.in);
                                String str = scanner.nextLine();
                                String pattern = "[\\d]+";
boolean matches = Pattern.matches(pattern, str);
if(matches){
                                    num = Integer.parseInt(str);
                                    fl = false;
                                }else{
System.out.println("------------------------------");
System.out.println();
System.out.println("[ "+str+" ] 只能包含数字");
System.out.println();
System.out.println("请输入数值：");
System.out.println();
                                }
                            }
                            TestHash.addNum(num);
                            // 打印当前 redis 数值
                            //TestHash.printRedisData();
                            // 发起二次输入
                            // 验证指令输入
if(errorFlag){
                                contextKey.add(contextKey.peek()+"_add");
                            }
                            instruction = TestHash.validataScanner(instructions.get(default2));
                            TestHash.invokeScanner(contextKey,instruction,false);
                        }
                        // 查询当前所有redis数据
if("4".equals(instruction)){
if(errorFlag){
                                contextKey.add(contextKey.peek()+"_findAll");
                            }
                            // 打印当前 redis 所有数据
                            TestHash.findAll();
                            // 发起二次输入
                            // 验证指令输入
if(errorFlag){
                                contextKey.add(contextKey.peek()+"_findAll");
                            }
                            instruction = TestHash.validataScanner(instructions.get(default2));
                            TestHash.invokeScanner(contextKey,instruction,false);
                        }
                        // 删除redis数据
else if("5".equals(instruction)){
if(errorFlag){
                                contextKey.add(contextKey.peek()+"_deleteRedisData");
                            }
System.out.println();
System.out.println("------------------------------");
System.out.println("请输入数值：");
Integer num = 0;
boolean fl = true;
while (fl){
                                // 开启输入模式
                                Scanner scanner = new Scanner(System.in);
                                String str = scanner.nextLine();
                                String pattern = "[\\d]+";
boolean matches = Pattern.matches(pattern, str);
if(matches){
                                    num = Integer.parseInt(str);
                                    fl = false;
                                }else{
System.out.println("------------------------------");
System.out.println();
System.out.println("[ "+str+" ] 只能包含数字");
System.out.println();
System.out.println("请输入数值：");
System.out.println();
                                }
                            }
                            TestHash.deleteData(num);
                            // 打印当前 redis 数值
                            //TestHash.printRedisData();
                            // 发起二次输入
                            // 验证指令输入
if(errorFlag){
                                contextKey.add(contextKey.peek()+"_delete");
                            }
                            instruction = TestHash.validataScanner(instructions.get(default2));
                            TestHash.invokeScanner(contextKey,instruction,false);
                        }
else{
                            //二级
if(keyList.size() > 2){
                                // 查询当前所有redis集群
if("getRedis".equals(keyList.get(2))){
                                    // 返回上一层
if("0".equals(instruction)){
                                        // 取两次 包含本次的正确 指令
                                        contextKey.pop();
                                        contextKey.pop();
                                        instructionKeys.pop();
                                        instructionKeys.pop();
                                        String instructionKeyTemp = null;
if(instructionKeys.size() > 0){
                                            instructionKeyTemp = instructionKeys.peek();
                                        }
                                        TestHash.invokeScanner(contextKey,instructionKeyTemp,true);
                                    }
                                }else if("addRedis".equals(keyList.get(2))){
                                    // 返回上一层
if("0".equals(instruction)){
                                        // 取两次 包含本次的正确 指令
                                        contextKey.pop();
                                        contextKey.pop();
                                        instructionKeys.pop();
                                        instructionKeys.pop();
                                        String instructionKeyTemp = null;
if(instructionKeys.size() > 0){
                                            instructionKeyTemp = instructionKeys.peek();
                                        }
                                        TestHash.invokeScanner(contextKey,instructionKeyTemp,true);
                                    }
                                }else if("addRedisData".equals(keyList.get(2))){
                                    // 返回上一层
if("0".equals(instruction)){
                                        // 取两次 包含本次的正确 指令
                                        contextKey.pop();
                                        contextKey.pop();
                                        instructionKeys.pop();
                                        instructionKeys.pop();
                                        String instructionKeyTemp = null;
if(instructionKeys.size() > 0){
                                            instructionKeyTemp = instructionKeys.peek();
                                        }
                                        TestHash.invokeScanner(contextKey,instructionKeyTemp,true);
                                    }
                                }else if("findAll".equals(keyList.get(2))){
                                    // 返回上一层
if("0".equals(instruction)){
                                        // 取两次 包含本次的正确 指令
                                        contextKey.pop();
                                        contextKey.pop();
                                        instructionKeys.pop();
                                        instructionKeys.pop();
                                        String instructionKeyTemp = null;
if(instructionKeys.size() > 0){
                                            instructionKeyTemp = instructionKeys.peek();
                                        }
                                        TestHash.invokeScanner(contextKey,instructionKeyTemp,true);
                                    }
                                }else if("deleteRedisData".equals(keyList.get(2))){
                                    // 返回上一层
if("0".equals(instruction)){
                                        // 取两次 包含本次的正确 指令
                                        contextKey.pop();
                                        contextKey.pop();
                                        instructionKeys.pop();
                                        instructionKeys.pop();
                                        String instructionKeyTemp = null;
if(instructionKeys.size() > 0){
                                            instructionKeyTemp = instructionKeys.peek();
                                        }
                                        TestHash.invokeScanner(contextKey,instructionKeyTemp,true);
                                    }
                                }
                            }
                        }
                    }
                }
            }
            // 如果没有拦截到 则狗咬狗尾巴
            String instructionKeyTemp = null;
if(instructionKeys.size() > 0){
                instructionKeyTemp = instructionKeys.peek();
            }
            TestHash.invokeScanner(contextKey,instructionKeyTemp,true);
        }catch (Exception e){
            //e.printStackTrace();
System.out.println(e.getMessage());
            // 错误
            TestHash.errorScanner(e.getMessage());
        }
    }
/**
     * 判断输入
     * @param map 指令集合
     */
public static String validataScanner(Map<String, String> map) throws Exception{
        // 打印指令
        TestHash.printScannerKeys(map);
        // 开启输入模式
        Scanner scanner = new Scanner(System.in);
        String str = scanner.nextLine();
        String obj = map.get(str);
if(obj != null){
            instructionKeys.add(str);
return str;
        }
        // 否则就报错
        throw new Exception(str);
    }
/**
     * 生成指令Key
     * @return
     */
public static String createInstructionKey() {
return contextKeys.peek();
    }
/**
     * 生成所有指令
     * @return
     */
public static Map<String,Map<String, String>> createInstructions() {
        //总 指令
        Map<String, Map<String, String>> map = new HashMap<>();
        //第一层指令
        Map<String, String> allMap = new TreeMap<>(new Comparator<String>() {
            @Override
public int compare(String o1, String o2) {
return o1.compareTo(o2);
            }
        });
        allMap.put("1","查询当前所有redis集群");
        allMap.put("2","增加集群");
        allMap.put("3","添加数据");
        allMap.put("4","查看所有数据");
        allMap.put("5","删除数据");
        map.put("system_top",allMap);
        //默认二级命令
        Map<String, String> default2Map = new TreeMap<>(new Comparator<String>() {
            @Override
public int compare(String o1, String o2) {
return o1.compareTo(o2);
            }
        });
        default2Map.put("0","返回上级菜单");
        map.put("default2",default2Map);
return map;
    }
/**
     * 输入错误
     */
public static void errorScanner(String str) {
        String strT = "";
if(!StringUtils.isEmpty(str)){
            strT = "[ "+str+" ] ";
        }
System.out.println();
System.out.println();
System.out.println();
System.out.println();
System.out.println();
System.out.println();
System.out.println(strT + "输入参数有误，请重新输入！");
System.out.println();
        String instructionKeyTemp = null;
if(instructionKeys.size() > 0){
            instructionKeyTemp = instructionKeys.peek();
        }
        // 回调
        TestHash.invokeScanner(contextKeys,instructionKeyTemp,true);
    }
/**
     * 打印指令
     */
public static void printScannerKeys(Map<String, String> map) {
        // 打印命令
Set<String> keySet = map.keySet();
        Iterator<String> iter = keySet.iterator();
System.out.println();
System.out.println("------------------------------");
while (iter.hasNext()) {
            String key = iter.next();
System.out.println("指令 [ "+key+" ]" + " " + map.get(key));
        }
System.out.println();
System.out.println("请输入指令：");
    }
/**
     * 打印当前redis服务器
     * @param map
     */
public static void printRedis(Map<Integer, String> map){
Set<Integer> keySet = map.keySet();
        Iterator<Integer> iter = keySet.iterator();
System.out.println();
while (iter.hasNext()) {
Integer key = iter.next();
System.out.println(key + ":" + map.get(key));
        }
System.out.println();
    }
}
文章标签：
云数据库 Tair（兼容 Redis）
Java
应用服务中间件
NoSQL
Redis
nginx
算法
缓存
关键词：
redis缓存
云数据库 Tair（兼容 Redis）缓存
多级缓存
缓存一致性
Nginx算法
相关实践学习
基于Redis实现在线游戏积分排行榜
本场景将介绍如何基于Redis数据库实现在线游戏中的游戏玩家积分排行榜功能。
云数据库 Redis 版使用教程
云数据库Redis版是兼容Redis协议标准的、提供持久化的内存数据库服务，基于高可靠双机热备架构及可无缝扩展的集群架构，满足高读写性能场景及容量需弹性变配的业务需求。 产品详情：https://www.aliyun.com/product/kvstore &nbsp; &nbsp; ------------------------------------------------------------------------- 阿里云数据库体验：数据库上云实战 开发者云会免费提供一台带自建MySQL的源数据库&nbsp;ECS 实例和一台目标数据库&nbsp;RDS实例。跟着指引，您可以一步步实现将ECS自建数据库迁移到目标数据库RDS。 点击下方链接，领取免费ECS&amp;RDS资源，30分钟完成数据库上云实战！https://developer.aliyun.com/adc/scenario/51eefbd1894e42f6bb9acacadd3f9121?spm=a2c6h.13788135.J_3257954370.9.4ba85f24utseFl
卢衍飞
目录
相关文章
光明顶阳顶天
|
29天前
|
负载均衡 算法 搜索推荐
Nginx 常用的负载均衡算法
【10月更文挑战第17天】在实际应用中，我们需要根据具体的情况来选择合适的负载均衡算法。同时，还可以结合其他的优化措施，如服务器健康检查、动态调整权重等，来进一步提高负载均衡的效果和系统的稳定性。
光明顶阳顶天
112 59
热爱技术的小郑
|
3月前
|
负载均衡 NoSQL 算法
一天五道Java面试题----第十天（简述Redis事务实现---------＞负载均衡算法、类型）
这篇文章是关于Java面试中Redis相关问题的笔记，包括Redis事务实现、集群方案、主从复制原理、CAP和BASE理论以及负载均衡算法和类型。
热爱技术的小郑
62 1
一天五道Java面试题----第十天（简述Redis事务实现---------＞负载均衡算法、类型）
mao29955
|
25天前
|
负载均衡 算法 应用服务中间件
Nginx 常用的负载均衡算法
【10月更文挑战第22天】不同的负载均衡算法各有特点和适用场景。在实际应用中，需要根据具体的业务需求、服务器性能和网络环境等因素来选择合适的算法。
mao29955
31 3
Dylaniou
|
1月前
|
算法 索引
HashMap扩容时的rehash方法中(e.hash & oldCap) == 0算法推导
HashMap在扩容时，会创建一个新数组，并将旧数组中的数据迁移过去。通过(e.hash & oldCap)是否等于0，数据被巧妙地分为两类：一类保持原有索引位置，另一类索引位置增加旧数组长度。此过程确保了数据均匀分布，提高了查询效率。
Dylaniou
38 2
java冯坚持
|
1月前
|
缓存 负载均衡 算法
nginx学习：配置文件详解，负载均衡三种算法学习，上接nginx实操篇
Nginx 是一款高性能的 HTTP 和反向代理服务器，也是一个通用的 TCP/UDP 代理服务器，以及一个邮件代理服务器和通用的 HTTP 缓存服务器。
java冯坚持
72 0
nginx学习：配置文件详解，负载均衡三种算法学习，上接nginx实操篇
竹子爱熊猫
|
3月前
|
存储 算法 NoSQL
(七)漫谈分布式之一致性算法下篇：一文从根上儿理解大名鼎鼎的Raft共识算法！
Raft通过一致性检查，能在一定程度上保证集群的一致性，但无法保证所有情况下的一致性，毕竟分布式系统各种故障层出不穷，如何在有可能发生各类故障的分布式系统保证集群一致性，这才是Raft等一致性算法要真正解决的问题。
竹子爱熊猫
113 11
竹子爱熊猫
|
3月前
|
存储 算法 索引
(六)漫谈分布式之一致性算法上篇：用二十六张图一探Raft共识算法奥妙之处！
现如今，大多数分布式存储系统都投向了Raft算法的怀抱，而本文就来聊聊大名鼎鼎的Raft算法/协议！
竹子爱熊猫
118 8
竹子爱熊猫
|
3月前
|
存储 算法 Java
(五)漫谈分布式之一致性算法篇：谁说Paxos晦涩难懂？你瞧这不一学就会！
没在时代发展的洪流中泯然于众的道理很简单，是因为它们并不仅是空中楼阁般的高大上理论，而是有着完整落地的思想，它们已然成为构建分布式系统不可或缺的底层基石，而本文则来好好聊聊分布式与一致性思想的落地者：Paxos与Raft协议（算法）。
竹子爱熊猫
98 6
竹子爱熊猫
|
4月前
|
缓存 负载均衡 算法
（四）网络编程之请求分发篇：负载均衡静态调度算法、平滑轮询加权、一致性哈希、最小活跃数算法实践！
先如今所有的技术栈中，只要一谈关于高可用、高并发处理相关的实现，必然会牵扯到集群这个话题，也就是部署多台服务器共同对外提供服务，从而做到提升系统吞吐量，优化系统的整体性能以及稳定性等目的。
竹子爱熊猫
78 2
萝卜丝丸子
|
4月前
|
监控 应用服务中间件 nginx
高并发架构设计三大利器：缓存、限流和降级问题之Nginx的并发连接数计数的问题如何解决
高并发架构设计三大利器：缓存、限流和降级问题之Nginx的并发连接数计数的问题如何解决
萝卜丝丸子
35 0

热门文章

最新文章

  • 1
    如何优雅打印nginx header和body
  • 2
    安装nginx：src/os/unix/ngx_user.c:26:7: error: ‘struct crypt_data’ has no member named ‘curren
  • 3
    [译]Nginx和Lua
  • 4
    又一款Nginx 管理可视化神器！通过界面完成配置监控，一条龙！
  • 5
    nginx跳转
  • 6
    nagios监控nginx status
  • 7
    nginx+keepalived构建主主负载均衡代理服务器
  • 8
    nginx HTTP Upstream模块
  • 9
    nginx禁止ip访问web
  • 10
    Nginx使用指南(一)
  • 1
    中间件Redis性能瓶颈
    108
  • 2
    Redis数据结构—跳跃表 skiplist 实现源码分析
    65
  • 3
    中间件键值存储模型Redis
    52
  • 4
    技术好文：Redis分布式锁的正确实现方式
    53
  • 5
    RDS（Relational Database Service）和Redis
    503
  • 6
    Redis 和 数据库区别
    57
  • 7
    搭建高可用及负载均衡的Redis
    142
  • 8
    【Azure Developer】一个复制Redis Key到另一个Redis服务的工具(redis_copy_net8)
    51
  • 9
    Redis数据结构—跳跃表 skiplist
    42
  • 10
    JSON 存入 Redis
    126

    • 相关课程

    更多
  • 智能创作赛（初赛）：相册应用中的故事生成算法介绍
  • 相册服务中的故事生成算法介绍
  • Nginx企业级Web服务实战
  • Go语言核心编程 - 数据结构和算法
  • Linux Web服务器Nginx搭建与配置
  • 神经网络概览及算法详解

    • 相关电子书

    更多
  • “大数据+算法”助力B2B未来商业
  • CentOS Nginx PHP JAVA 多语言镜像使用手
  • CentOS Nginx PHP JAVA多语言镜像使用手册

    • 相关实验场景

    更多
  • 基于Redis实现在线游戏积分排行榜
  • 使用Swing算法实现商品推荐
  • RSA密码算法设计与实现
  • RSA非对称加密算法
  • 欧拉图的构造性证明与算法实现
  • Tair for Redis数据闪回：任意时间点数据恢复
    • 下一篇
    无影云桌面