soyo的跨机房部署、同城双活、异地多活、9个9高可用博客yuque笔记同步site

CompletableFuture.allOf(futures).get(timeout, TimeUnit.MILLISECONDS);

//1.计算结果完成，或者异常时执行给定action(当前线程执行)
CompletableFuture<T> whenComplete(BiConsumer<? super T, ? super Throwable> action);
//2.计算结果完成，或者异常时执行给定action（另起线程执行）
CompletableFuture<T> whenCompleteAsync(BiConsumer<? super T, ? super Throwable> action);
//3.执行完成时对结果进行处理，还可以处理异常
<U> CompletableFuture<U> handle(BiFunction<? super T, Throwable, ? extends U> fn)
//4.异常时，返回指定结果
CompletableFuture<T> exceptionally(Function<Throwable, ? extends T> fn)

//主线程
main {
  //doSomething是在异步线程里，回调是在主线程
  doSomething().async().addListener(new Listener(){
    @Override
    public void complete() throws Exception {
      //do your job
    }
  });
}

package com.soyo.simple;

/**
 * @author: lkl
 * @date: 2025/9/12 22:24
 */
public class Bootstrap {

    public static void main(String[] args) {
        Bootstrap bootstrap = new Bootstrap();
        Worker worker = bootstrap.newWorker();

        Wrapper wrapper = new Wrapper();
        wrapper.setWorker(worker);
        wrapper.setParam("hello");

        //2.回调方法，输出worker中的内容
        bootstrap.doWorker(wrapper).addListener(new Listener() {
            @Override
            public void callback(Object result) {
                System.out.println(Thread.currentThread().getName());
                System.out.println(result);
            }
        });

        //1.主线程不阻塞，打印当前线程
        System.out.println(Thread.currentThread().getName());
    }

    private Wrapper doWorker(Wrapper wrapper) {
        new Thread(() -> {
            Worker worker = wrapper.getWorker();
            String result = worker.action(wrapper.getParam());
            wrapper.getListener().callback(result);
        }).start();

        return wrapper;
    }

    private Worker newWorker() {
        return new Worker() {
            @Override
            public String action(String obj) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                return obj + " callback!";
            }
        };
    }

}

public static ExecutorService newCachedThreadPool() {
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                  60L, TimeUnit.SECONDS,
                                  new SynchronousQueue<Runnable>());
}

package com.grace.gateway.core.algorithm;

import java.util.List;
import java.util.SortedMap;
import java.util.TreeMap;

public class ConsistentHashing {

    private final int virtualNodeNum;

    // 哈希环
    private final SortedMap<Integer, String> hashCircle = new TreeMap<>();

    // 构造函数，初始化一致性哈希环
    public ConsistentHashing(List<String> nodes, int virtualNodeNum) {
        this.virtualNodeNum = virtualNodeNum;
        for (String node : nodes) {
            addNode(node);
        }
    }

    public void addNode(String node) {
        for (int i = 0; i < virtualNodeNum; i++) {
            String virtualNode = node + "&&VN" + i;
            hashCircle.put(getHash(virtualNode), node);
        }
    }

    public String getNode(String key) {
        if (hashCircle.isEmpty()) {
            return null;
        }
        int hash = getHash(key);
        SortedMap<Integer, String> tailMap = hashCircle.tailMap(hash);
        Integer nodeHash = tailMap.isEmpty() ? hashCircle.firstKey() : tailMap.firstKey();
        return hashCircle.get(nodeHash);
    }

    private int getHash(String str) {
        final int p = 16777619;
        int hash = (int) 2166136261L;
        for (int i = 0; i < str.length(); i++) {
            hash = (hash ^ str.charAt(i)) * p;
        }
        hash += hash << 13;
        hash ^= hash >> 7;
        hash += hash << 3;
        hash ^= hash >> 17;
        hash += hash << 5;
        if (hash < 0) {
            hash = Math.abs(hash);
        }
        return hash;
    }

}

@Override
public ServiceInstance selectInstance(GatewayContext context, List<ServiceInstance> instances) {
    int totalWeight = instances.stream().mapToInt(ServiceInstance::getWeight).sum();
    if (totalWeight <= 0) return null;
    int randomWeight = ThreadLocalRandom.current().nextInt(totalWeight);
    for (ServiceInstance instance : instances) {
        randomWeight -= instance.getWeight();
        if (randomWeight < 0) return instance;
    }
    return null;
}

class Solution {
    public int[] dailyTemperatures(int[] temperatures) {
        //维护一个单调递增栈，用来存放已经遍历过的元素，然后就可以与当前元素进行一个比较
        //该题是一个单调递减栈，栈顶 --> 栈低 是递增的
        Stack<Integer> stack = new Stack<>();
        int[] res = new int[temperatures.length];
        for (int i = 0; i < temperatures.length; i++) {
            //队列不为空 然后如果当前元素大于那个已经遍历过的元素，那就去清理旧账 
            while (!stack.isEmpty() && temperatures[stack.peek()] < temperatures[i]) {
                int curIndex = stack.pop();
                //求的是间隔
                res[curIndex] = i - curIndex;
            }
            stack.add(i);
        }
        return res;
    }
}

class Solution {
    //以 heights[i]为高的 矩形面积有多大
    //heights[i] 为基准
    public int largestRectangleArea(int[] heights) {
        int n = heights.length;
        int[] newHeights = new int[n+2];
        newHeights[0] = 0;
        newHeights[newHeights.length - 1] = 0;
        System.arraycopy(heights, 0, newHeights, 1 , n);
        //System.out.println(Arrays.toString(newHeights));

        Stack<Integer> s = new Stack();
        s.add(0);
        int res = 0;
        for(int i = 0; i < newHeights.length; i++){
            while(!s.isEmpty() && newHeights[i] < newHeights[s.peek()]){
                int midIndex = s.pop();
                if(s.isEmpty()){
                    break;
                }
                int leftIndex = s.peek();
                //以h(mid)为高度 左右扩展的范围
                // leftIndex midIndex .... i
                int range = i - leftIndex - 1;
                res = Math.max(res, newHeights[midIndex] * range);
            }
            s.add(i);
        }
        return res;
    }
}

class Solution {
    int res = 0;
    public int maximalRectangle(char[][] matrix) {
        int[][] t = new int[matrix.length][matrix[0].length + 2];
        for(int i = 0; i < t.length; i++){
            t[i][0] = 0; 
            t[i][t[0].length - 1] = 0; 
        }
        // 转换成 84题那种柱状图
        for(int i = 0; i < t.length; i++){
            for(int j = 1; j < t[0].length - 1; j++){
                if(matrix[i][j - 1] == '1'){
                    t[i][j] = 1;
                    //当前 位置为 1时，才能有高度
                    if(i > 0) t[i][j] += t[i - 1][j];
                }
                else t[i][j] = 0;
                
            }
        }
        // for(int [] tt: t){
        //     System.out.println(Arrays.toString(tt));
        // }

        for(int[] tt: t){
            f1(tt);
        }
        return res;        
    }
    public void f1(int []hegihts){
        Stack<Integer> s = new Stack();
        s.add(0);
        for(int i = 1; i < hegihts.length; i++){
            while(!s.isEmpty() && hegihts[s.peek()] > hegihts[i]){
                int midIndex = s.pop();
                if(s.isEmpty()){
                    break;
                }
                int leftIndex = s.peek();
                res = Math.max(res, hegihts[midIndex] * (i - leftIndex - 1));
            }
            s.add(i);
        }
    }
}

class Solution {
    public int findLength(int[] nums1, int[] nums2) {
        //dp吧
        //dp数组表示什么? : 以 i结尾的nums1 以j 结尾的nums2 ，最大的子数组长度
        //遍历顺序
        //状态方程
        //dp数组就表示 
        // 1 2 3 4
        // 1 2 3 5

        // 1 2 3 4 6
        // 1 2 5 4 
        int [][]dp  = new int[nums1.length+1][nums2.length+1];
        int res=0;
        for(int i=0;i<nums1.length;i++){
            for(int j=0;j<nums2.length;j++){
                if(nums1[i]==nums2[j]){
                    dp[i+1][j+1]=dp[i][j]+1;
                    res=Math.max(res,dp[i+1][j+1]);
                }
            }
        }
        return res;
    }
}

class Solution {
    public int maxProfit(int[] prices) {
        int res =0;
        //上帝视角看
        //我们要实现最大利润，那么从股票走势图来看就是 递增的每一段我都要赚，只要第二天涨价我就卖，每一段上升期我都吃
        for(int i=1;i<prices.length;i++){
            if(prices[i]-prices[i-1]>0){
                res+=prices[i]-prices[i-1];
            }
        }
        return res;
    }
}

class Solution {
    public int maxProfit(int[] prices) {
        //dp : i 这一天可获得的最大利润
        // 股票状态：有或者没有
        int [][] dp = new int[prices.length][2];
        dp[0][0] = -prices[0];
        dp[0][1] = 0;
        for(int i=1;i<prices.length;i++){
            //0:有：昨天有今天继续持有 or 昨天没有但今天买入
            dp[i][0]=Math.max(dp[i-1][0],dp[i-1][1]-prices[i]);
            //1:没有：昨天没有今天继续没有 or 昨天有但今天卖出
            dp[i][1]=Math.max(dp[i-1][1],dp[i-1][0]+prices[i]);
        }
        //因为最后一天手里 不能有股票 才是最大利润（卖掉股票才是真实收益）。
        return dp[prices.length-1][1];
    }
}

class Solution {
    public int uniquePaths(int m, int n) {
        //dp：表示达到该位置i j最大有多少条路径
        int [][] dp = new int[m][n];
        //初始化
        dp[0][0]=1;
        for(int i=1;i<m;i++){
            dp[i][0]=1;
        }
        for(int j=1;j<n;j++){
            dp[0][j]=1;
        }
        for(int i=1;i<m;i++){
            for(int j=1;j<n;j++){
                //状态推导，当前位置 = 左 + 上
                dp[i][j]=dp[i-1][j]+dp[i][j-1];
            }
        }
        return dp[m-1][n-1];
    }
}

class Solution {
    public int minDistance(String word1, String word2) {
        int [][]dp=new int[word1.length()+1][word2.length()+1];
        //dp[i][j]  表示 word 中前 i个字符，变换到word2中的 前j个字符，需要的最小次数
        // dp[0][0] 表示 空字符串

        //
        for(int i=0;i<=word1.length();i++){
           dp[i][0]=i;
        }
        for(int j=0;j<=word2.length();j++){
            dp[0][j]=j;
        }
        for(int i=1;i<=word1.length();i++){
            for(int j=1;j<=word2.length();j++){
                
                //eg：
                // ros i=2
                // rs i=1
                //特殊情况 word1[i-1]==word[j-1]
                if(word1.charAt(i-1)==word2.charAt(j-1)){
                   dp[i][j]=dp[i-1][j-1];
                }
                //当前状态 是增，删，改 哪个操作数小？
                else dp[i][j]=Math.min(dp[i-1][j-1],Math.min(dp[i-1][j],dp[i][j-1]))+1;
            }
        }
        return dp[word1.length()][word2.length()];
    }
}

class Solution {
    public int climbStairs(int n) {
        if(n < 2) return n; 
        int []dp = new int[n+1];
        dp[0] = 1;
        dp[1] = 1;
        dp[2] = 2;
        //4
        //1:1
        //2:2
        //3: 2
        for(int i = 3;i <= n;i++){
            //两种情况：比如我在三阶梯，我可以从一阶梯一下子两步上来，以及从二阶梯一步上来
            dp[i] = dp[i-1] + dp[i-2]; 
        }
        return dp[n];
    }
}

class Solution {
    public int coinChange(int[] coins, int amount) {
        //dp数组含义： 构成当前金额的最小硬币数
        //dp[i] = dp[ i - cions ] + 1 
        if(amount <= 0){
            return 0;
        }
        int []dp = new int[amount+1];
        Arrays.fill(dp,Integer.MAX_VALUE);
        dp[0] = 0;
        for(int i = 0;i < dp.length;i++){
            for(int j = 0;j<coins.length;j++){
                if( i - coins[j] >= 0 && dp[i-coins[j]] != Integer.MAX_VALUE){
                    dp[i] = Math.min(dp[i-coins[j]] + 1, dp[i]);
                }
            }
        }
        System.out.println(Arrays.toString(dp));
        return dp[amount] == Integer.MAX_VALUE? -1: dp[amount];
    }
}

class Solution {
    public int maximalSquare(char[][] matrix) { 
        int n = matrix.length;
        int m = matrix[0].length;
        //dp数组含义 dp[i][j] 表示：以 matrix[i][j] 为右下角的最大正方形边长。
        int[][] dp = new int[n][m];
        int res = 0;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if(matrix[i][j] == '1') {
                    if(i == 0|| j == 0){
                        dp[i][j] = 1;
                    }
                    //min (相邻三个正方形) + 1
                    else dp[i][j] = Math.min(dp[i - 1][j - 1], Math.min(dp[i][j - 1], dp[i - 1][j])) + 1;
                    res = Math.max(res, dp[i][j]);
                }
            }
        }
        return res * res;
    }
}

class Solution {
    public int rob(int[] nums) {
        if(nums.length == 1) return nums[0];
        int []dp = new int[nums.length];
        //dp数组含义 小偷走到当前i index房子时 能偷的最高金额
        //初始化
        dp[0] = nums[0];
        dp[1] = Math.max(nums[0], nums[1]);
        int res = dp[1];
        for(int i = 2;i < nums.length; i++){
            //两种情况 偷 or 不偷，且不能相邻偷
            dp[i] = Math.max(dp[i - 2] + nums[i], dp[i - 1]);
            res = Math.max(res, dp[i]);
        }
        return res;
    }
}

class Solution {
    public int rob(int[] nums) {
        if(nums.length == 1) return nums[0];
        int []dp = new int[nums.length];
        //dp数组含义 小偷走到当前i index房子时 能偷的最高金额
        //初始化
        dp[0] = nums[0];
        dp[1] = Math.max(nums[0], nums[1]);
        int res = dp[1];
        
        //路径
        List<Integer> resList = new ArrayList<>(); 
        //resList.add();
        for(int i = 2;i < nums.length; i++){
            //偷 or 不偷
            if(dp[i - 2] + nums[i] > dp[i - 1]){
                if(i == 2) resList.add(dp[0]);
                resList.add(nums[i]);
            }
            //两种情况 偷 or 不偷，且不能相邻偷
            dp[i] = Math.max(dp[i-2] + nums[i], dp[i - 1]);
            res = Math.max(res, dp[i]);
        }
        System.out.println(resList);
        return res;
    }
}

class Solution {
    public boolean wordBreak(String s, List<String> wordDict) {
        //dp数组含义 以i为结尾的字符串，是否可以被转换
        HashSet<String> set = new HashSet(wordDict);
        boolean[] dp = new boolean[s.length()];
        for (int i = 0; i < s.length(); i++) {
            for (int j = 0; j <= i; j++) {
                //j...i
                String sub = s.substring(j, i + 1);
                // 0...j...i
                //这里的条件成立为两部分：[0..j-1] [j...i] 可以被分隔
                //两者共同使 以i为结尾的字符串，是否可以被转换
                if ((j == 0 || dp[j - 1]) && set.contains(sub)) {
                    dp[i] = true;
                    break;
                }
            }
        }
        return dp[s.length() - 1];
    }
}

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public int rob(TreeNode root) {
        int[] res = dfs(root);
        //最后这里，就是当前节点抢不抢的问题
        return Math.max(res[0], res[1]);
    }
    public int[] dfs(TreeNode root){
        if(root == null){
            return new int[]{0,0}; //怎么选都是没有的
        }
        int []left = dfs(root.left);
        int []right = dfs(root.right);
        //当前节点抢，则 左右子节点必须为 不抢的
        int rob = left[1] + right[1] + root.val; 
        //当前节点不抢，则 从左右子节点取 最大的，然后一起带上来当前节点
        int noRob = Math.max(left[0], left[1]) + Math.max(right[0], right[1]);
        return new int[]{rob, noRob};
    } 
}

class Solution {
    public int maxProfit(int[] prices) {
        //status: 0 没持有 1 持有
        // 有冻结期 无非就是 今天卖出 明天不能买入、
        //prices 是指同一只股票的价格啊！！！！！   
        //dp数组含义：第i天 没持有or持有 的利润
        int[][] dp = new int[prices.length][2];
        dp[0][0] = 0;
        dp[0][1] = -prices[0];
        for (int i = 1; i < prices.length; i++) {

            //没持有，可能是 继续没持有，或者 在昨天持有股票的基础上 在今天以今天股票的价格股票给卖了
            dp[i][0] = Math.max(dp[i - 1][0], dp[i - 1][1] + prices[i]);


            //持有：可能是继续持有股票 或者是 前天把股票卖出了，然后以今天以今天股票的价格把股票买入了（为什么只能前天，因为不能昨天卖出，然后第二天买入）
            //不能同时拥有多只股票，其实只有一直股票
            if (i == 1)
                dp[i][1] = Math.max(dp[i - 1][1], dp[i - 1][0] - prices[i]);
            else
                //不能同时参与多笔交易
                
                dp[i][1] = Math.max(dp[i - 1][1], dp[i - 2][0] - prices[i]);
            
            
        }
        //最后肯定得把股票卖了，即没持有，才能实现利益最大化
        return dp[prices.length - 1][0];
    }
}

class Solution {
    public int[] countBits(int n) {
        //0 -> 0
        //1 -> 1
        //2 -> 10
        //3 -> 11 3/2 == 1 & 1 
        //4 -> 100 4/2 == 2 
        //5 -> 101 5/2 == 2
        //6 -> 110
        //7 -> 111 
        //8 -> 1000 2的3次方 8/2 == 3
        int[] res = new int[n + 1];
        if(n < 1) return res; 
        res[0] = 0;
        res[1] = 1;
        for(int i = 2; i <= n; i++){
            int num = i;
            if(num % 2 == 0){
                res[i] = res[num / 2];
            }
            else {
                res[i] = res[num / 2] + 1;
            }

        }
        return res;
    }
}