常见负载均衡算法及路由策略

最新推荐文章于 2024-04-24 23:03:39 发布
最新推荐文章于 2024-04-24 23:03:39 发布
阅读量1.1k 收藏 2
点赞数
分类专栏： java 文章标签： java 算法 负载均衡
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/grant167/article/details/108694647
版权

总是第一个

xxl-job的实现方式

com.xxl.job.admin.core.route.strategy.ExecutorRouteFirst
@Override
public ReturnT<String> route(TriggerParam triggerParam, List<String> addressList){
    return new ReturnT<String>(addressList.get(0));
}

最后一个

com.xxl.job.admin.core.route.strategy.ExecutorRouteLast
@Override
public ReturnT<String> route(TriggerParam triggerParam, List<String> addressList) {
    return new ReturnT<String>(addressList.get(addressList.size()-1));
}

轮询

xxl-job的实现方式

com.xxl.job.admin.core.route.strategy.ExecutorRouteRound
//conmap 按jobId迭代自增count，然后按address.size取余
private static ConcurrentMap<Integer, Integer> routeCountEachJob = new ConcurrentHashMap<Integer, Integer>();
private static long CACHE_VALID_TIME = 0;
private static int count(int jobId) {
    // cache clear
    if (System.currentTimeMillis() > CACHE_VALID_TIME) {
        routeCountEachJob.clear();
        CACHE_VALID_TIME = System.currentTimeMillis() + 1000*60*60*24;
    }

    // count++
    Integer count = routeCountEachJob.get(jobId);
    count = (count==null || count>1000000)?(new Random().nextInt(100)):++count;  // 初始化时主动Random一次，缓解首次压力
    routeCountEachJob.put(jobId, count);
    return count;
}

@Override
public ReturnT<String> route(TriggerParam triggerParam, List<String> addressList) {
    String address = addressList.get(count(triggerParam.getJobId())%addressList.size());
    return new ReturnT<String>(address);
}

dubbo的实现方式

public class RoundRobinLoadBalance extends AbstractLoadBalance {
    public static final String NAME = "roundrobin";

    private static final int RECYCLE_PERIOD = 60000;

    protected static class WeightedRoundRobin {
        private int weight;
        private AtomicLong current = new AtomicLong(0);
        private long lastUpdate;

        public int getWeight() {
            return weight;
        }

        public void setWeight(int weight) {
            this.weight = weight;
            current.set(0);
        }

        public long increaseCurrent() {
            return current.addAndGet(weight);
        }

        public void sel(int total) {
            current.addAndGet(-1 * total);
        }

        public long getLastUpdate() {
            return lastUpdate;
        }

        public void setLastUpdate(long lastUpdate) {
            this.lastUpdate = lastUpdate;
        }
    }

    private ConcurrentMap<String, ConcurrentMap<String, WeightedRoundRobin>> methodWeightMap = new ConcurrentHashMap<String, ConcurrentMap<String, WeightedRoundRobin>>();

    /**
     * get invoker addr list cached for specified invocation
     * <p>
     * <b>for unit test only</b>
     *
     * @param invokers
     * @param invocation
     * @return
     */
    protected <T> Collection<String> getInvokerAddrList(List<Invoker<T>> invokers, Invocation invocation) {
        String key = invokers.get(0).getUrl().getServiceKey() + "." + invocation.getMethodName();
        Map<String, WeightedRoundRobin> map = methodWeightMap.get(key);
        if (map != null) {
            return map.keySet();
        }
        return null;
    }

    @Override
    protected <T> Invoker<T> doSelect(List<Invoker<T>> invokers, URL url, Invocation invocation) {
        String key = invokers.get(0).getUrl().getServiceKey() + "." + invocation.getMethodName();
        ConcurrentMap<String, WeightedRoundRobin> map = methodWeightMap.computeIfAbsent(key, k -> new ConcurrentHashMap<>());
        int totalWeight = 0;
        long maxCurrent = Long.MIN_VALUE;
        long now = System.currentTimeMillis();
        Invoker<T> selectedInvoker = null;
        WeightedRoundRobin selectedWRR = null;
        for (Invoker<T> invoker : invokers) {
            String identifyString = invoker.getUrl().toIdentityString();
            int weight = getWeight(invoker, invocation);
            WeightedRoundRobin weightedRoundRobin = map.computeIfAbsent(identifyString, k -> {
                WeightedRoundRobin wrr = new WeightedRoundRobin();
                wrr.setWeight(weight);
                return wrr;
            });

            if (weight != weightedRoundRobin.getWeight()) {
                //weight changed
                weightedRoundRobin.setWeight(weight);
            }
            long cur = weightedRoundRobin.increaseCurrent();
            weightedRoundRobin.setLastUpdate(now);
            if (cur > maxCurrent) {
                maxCurrent = cur;
                selectedInvoker = invoker;
                selectedWRR = weightedRoundRobin;
            }
            totalWeight += weight;
        }
        if (invokers.size() != map.size()) {
            map.entrySet().removeIf(item -> now - item.getValue().getLastUpdate() > RECYCLE_PERIOD);
        }
        if (selectedInvoker != null) {
            selectedWRR.sel(totalWeight);
            return selectedInvoker;
        }
        // should not happen here
        return invokers.get(0);
    }

}

随机

com.xxl.job.admin.core.route.strategy.ExecutorRouteRandom
@Override
public ReturnT<String> route(TriggerParam triggerParam, List<String> addressList) {
    String address = addressList.get(localRandom.nextInt(addressList.size()));
    return new ReturnT<String>(address);
}

一致性hash

xxl-job

//通过TreeMap实现一致性hash算法
//TreeMap.tailMap，作用是获取比指定的 key 大的数据集合

//md5散列的方式计算hash值
//其他的还有fnv1_32_hash算法，ketama等

// 分组下机器地址相同，不同JOB均匀散列在不同机器上，保证分组下机器分配JOB平均；且每个JOB固定调度其中一台机器；
//     a、virtual node：解决不均衡问题
//     b、hash method replace hashCode：String的hashCode可能重复，需要进一步扩大hashCode的取值范围

com.xxl.job.admin.core.route.strategy.ExecutorRouteConsistentHash

private static int VIRTUAL_NODE_NUM = 100;

/**
 * get hash code on 2^32 ring (md5散列的方式计算hash值)
 * @param key
 * @return
 */
private static long hash(String key) {

    // md5 byte
    MessageDigest md5;
    try {
        md5 = MessageDigest.getInstance("MD5");
    } catch (NoSuchAlgorithmException e) {
        throw new RuntimeException("MD5 not supported", e);
    }
    md5.reset();
    byte[] keyBytes = null;
    try {
        keyBytes = key.getBytes("UTF-8");
    } catch (UnsupportedEncodingException e) {
        throw new RuntimeException("Unknown string :" + key, e);
    }

    md5.update(keyBytes);
    byte[] digest = md5.digest();

    // hash code, Truncate to 32-bits
    long hashCode = ((long) (digest[3] & 0xFF) << 24)
            | ((long) (digest[2] & 0xFF) << 16)
            | ((long) (digest[1] & 0xFF) << 8)
            | (digest[0] & 0xFF);

    long truncateHashCode = hashCode & 0xffffffffL;
    return truncateHashCode;
}

public String hashJob(int jobId, List<String> addressList) {

    // ------A1------A2-------A3------
    // -----------J1------------------
    TreeMap<Long, String> addressRing = new TreeMap<Long, String>();
    for (String address: addressList) {
        for (int i = 0; i < VIRTUAL_NODE_NUM; i++) {
            long addressHash = hash("SHARD-" + address + "-NODE-" + i);
            addressRing.put(addressHash, address);
        }
    }

    long jobHash = hash(String.valueOf(jobId));
    SortedMap<Long, String> lastRing = addressRing.tailMap(jobHash);
    if (!lastRing.isEmpty()) {
        return lastRing.get(lastRing.firstKey());
    }
    return addressRing.firstEntry().getValue();
}

@Override
public ReturnT<String> route(TriggerParam triggerParam, List<String> addressList) {
    String address = hashJob(triggerParam.getJobId(), addressList);
    return new ReturnT<String>(address);
}

dubbo实现方式

package org.apache.dubbo.rpc.cluster.loadbalance;

import static org.apache.dubbo.common.constants.CommonConstants.COMMA_SPLIT_PATTERN;

/**
 * ConsistentHashLoadBalance
 */
public class ConsistentHashLoadBalance extends AbstractLoadBalance {
    public static final String NAME = "consistenthash";

    /**
     * Hash nodes name
     */
    public static final String HASH_NODES = "hash.nodes";

    /**
     * Hash arguments name
     */
    public static final String HASH_ARGUMENTS = "hash.arguments";

    private final ConcurrentMap<String, ConsistentHashSelector<?>> selectors = new ConcurrentHashMap<String, ConsistentHashSelector<?>>();

    @SuppressWarnings("unchecked")
    @Override
    protected <T> Invoker<T> doSelect(List<Invoker<T>> invokers, URL url, Invocation invocation) {
        String methodName = RpcUtils.getMethodName(invocation);
        String key = invokers.get(0).getUrl().getServiceKey() + "." + methodName;
        // using the hashcode of list to compute the hash only pay attention to the elements in the list
        int invokersHashCode = invokers.hashCode();
        ConsistentHashSelector<T> selector = (ConsistentHashSelector<T>) selectors.get(key);
        if (selector == null || selector.identityHashCode != invokersHashCode) {
            selectors.put(key, new ConsistentHashSelector<T>(invokers, methodName, invokersHashCode));
            selector = (ConsistentHashSelector<T>) selectors.get(key);
        }
        return selector.select(invocation);
    }

    private static final class ConsistentHashSelector<T> {

        private final TreeMap<Long, Invoker<T>> virtualInvokers;

        private final int replicaNumber;

        private final int identityHashCode;

        private final int[] argumentIndex;

        ConsistentHashSelector(List<Invoker<T>> invokers, String methodName, int identityHashCode) {
            this.virtualInvokers = new TreeMap<Long, Invoker<T>>();
            this.identityHashCode = identityHashCode;
            URL url = invokers.get(0).getUrl();
            this.replicaNumber = url.getMethodParameter(methodName, HASH_NODES, 160);
            String[] index = COMMA_SPLIT_PATTERN.split(url.getMethodParameter(methodName, HASH_ARGUMENTS, "0"));
            argumentIndex = new int[index.length];
            for (int i = 0; i < index.length; i++) {
                argumentIndex[i] = Integer.parseInt(index[i]);
            }
            for (Invoker<T> invoker : invokers) {
                String address = invoker.getUrl().getAddress();
                for (int i = 0; i < replicaNumber / 4; i++) {
                    byte[] digest = Bytes.getMD5(address + i);
                    for (int h = 0; h < 4; h++) {
                        long m = hash(digest, h);
                        virtualInvokers.put(m, invoker);
                    }
                }
            }
        }

        public Invoker<T> select(Invocation invocation) {
            String key = toKey(invocation.getArguments());
            byte[] digest = Bytes.getMD5(key);
            return selectForKey(hash(digest, 0));
        }

        private String toKey(Object[] args) {
            StringBuilder buf = new StringBuilder();
            for (int i : argumentIndex) {
                if (i >= 0 && i < args.length) {
                    buf.append(args[i]);
                }
            }
            return buf.toString();
        }

        private Invoker<T> selectForKey(long hash) {
            Map.Entry<Long, Invoker<T>> entry = virtualInvokers.ceilingEntry(hash);
            if (entry == null) {
                entry = virtualInvokers.firstEntry();
            }
            return entry.getValue();
        }

        private long hash(byte[] digest, int number) {
            return (((long) (digest[3 + number * 4] & 0xFF) << 24)
                    | ((long) (digest[2 + number * 4] & 0xFF) << 16)
                    | ((long) (digest[1 + number * 4] & 0xFF) << 8)
                    | (digest[number * 4] & 0xFF))
                    & 0xFFFFFFFFL;
        }
    }

最不经常使用

//最不经常使用 LFU
//通过concurrenthashmap<jobId,hashmap<addressIpPort,Count>>
//每次增加访问叠加1，value通过arraylist进行排序取最小值
com.xxl.job.admin.core.route.strategy.ExecutorRouteLFU

private static ConcurrentMap<Integer, HashMap<String, Integer>> jobLfuMap = new ConcurrentHashMap<Integer, HashMap<String, Integer>>();
private static long CACHE_VALID_TIME = 0;

public String route(int jobId, List<String> addressList) {

    // cache clear
    if (System.currentTimeMillis() > CACHE_VALID_TIME) {
        jobLfuMap.clear();
        CACHE_VALID_TIME = System.currentTimeMillis() + 1000*60*60*24;
    }

    // lfu item init
    HashMap<String, Integer> lfuItemMap = jobLfuMap.get(jobId);     // Key排序可以用TreeMap+构造入参Compare；Value排序暂时只能通过ArrayList；
    if (lfuItemMap == null) {
        lfuItemMap = new HashMap<String, Integer>();
        jobLfuMap.putIfAbsent(jobId, lfuItemMap);   // 避免重复覆盖
    }

    // put new
    for (String address: addressList) {
        if (!lfuItemMap.containsKey(address) || lfuItemMap.get(address) >1000000 ) {
            lfuItemMap.put(address, new Random().nextInt(addressList.size()));  // 初始化时主动Random一次，缓解首次压力
        }
    }
    // remove old
    List<String> delKeys = new ArrayList<>();
    for (String existKey: lfuItemMap.keySet()) {
        if (!addressList.contains(existKey)) {
            delKeys.add(existKey);
        }
    }
    if (delKeys.size() > 0) {
        for (String delKey: delKeys) {
            lfuItemMap.remove(delKey);
        }
    }

    // load least userd count address
    List<Map.Entry<String, Integer>> lfuItemList = new ArrayList<Map.Entry<String, Integer>>(lfuItemMap.entrySet());
    Collections.sort(lfuItemList, new Comparator<Map.Entry<String, Integer>>() {
        @Override
        public int compare(Map.Entry<String, Integer> o1, Map.Entry<String, Integer> o2) {
            return o1.getValue().compareTo(o2.getValue());
        }
    });

    Map.Entry<String, Integer> addressItem = lfuItemList.get(0);
    String minAddress = addressItem.getKey();
    addressItem.setValue(addressItem.getValue() + 1);

    return addressItem.getKey();
}

最近最久未使用

最近最久未使用 LRU
com.xxl.job.admin.core.route.strategy.ExecutorRouteLRU

private static ConcurrentMap<Integer, LinkedHashMap<String, String>> jobLRUMap = new ConcurrentHashMap<Integer, LinkedHashMap<String, String>>();
private static long CACHE_VALID_TIME = 0;

public String route(int jobId, List<String> addressList) {

    // cache clear
    if (System.currentTimeMillis() > CACHE_VALID_TIME) {
        jobLRUMap.clear();
        CACHE_VALID_TIME = System.currentTimeMillis() + 1000*60*60*24;
    }

    // init lru
    LinkedHashMap<String, String> lruItem = jobLRUMap.get(jobId);
    if (lruItem == null) {
        /**
         * LinkedHashMap
         *      a、accessOrder：true=访问顺序排序（get/put时排序）；false=插入顺序排期；
         *      b、removeEldestEntry：新增元素时将会调用，返回true时会删除最老元素；可封装LinkedHashMap并重写该方法，比如定义最大容量，超出是返回true即可实现固定长度的LRU算法；
         */
        lruItem = new LinkedHashMap<String, String>(16, 0.75f, true);
        jobLRUMap.putIfAbsent(jobId, lruItem);
    }

    // put new
    for (String address: addressList) {
        if (!lruItem.containsKey(address)) {
            lruItem.put(address, address);
        }
    }
    // remove old
    List<String> delKeys = new ArrayList<>();
    for (String existKey: lruItem.keySet()) {
        if (!addressList.contains(existKey)) {
            delKeys.add(existKey);
        }
    }
    if (delKeys.size() > 0) {
        for (String delKey: delKeys) {
            lruItem.remove(delKey);
        }
    }

    // load
    String eldestKey = lruItem.entrySet().iterator().next().getKey();
    String eldestValue = lruItem.get(eldestKey);
    return eldestValue;
}

最少活跃调用数

/**
 * LeastActiveLoadBalance
 * <p>
 * Filter the number of invokers with the least number of active calls and count the weights and quantities of these invokers.
 * If there is only one invoker, use the invoker directly;
 * if there are multiple invokers and the weights are not the same, then random according to the total weight;
 * if there are multiple invokers and the same weight, then randomly called.
 */
public class LeastActiveLoadBalance extends AbstractLoadBalance {

    public static final String NAME = "leastactive";

    @Override
    protected <T> Invoker<T> doSelect(List<Invoker<T>> invokers, URL url, Invocation invocation) {
        // Number of invokers
        int length = invokers.size();
        // The least active value of all invokers
        int leastActive = -1;
        // The number of invokers having the same least active value (leastActive)
        int leastCount = 0;
        // The index of invokers having the same least active value (leastActive)
        int[] leastIndexes = new int[length];
        // the weight of every invokers
        int[] weights = new int[length];
        // The sum of the warmup weights of all the least active invokers
        int totalWeight = 0;
        // The weight of the first least active invoker
        int firstWeight = 0;
        // Every least active invoker has the same weight value?
        boolean sameWeight = true;


        // Filter out all the least active invokers
        for (int i = 0; i < length; i++) {
            Invoker<T> invoker = invokers.get(i);
            // Get the active number of the invoker
            int active = RpcStatus.getStatus(invoker.getUrl(), invocation.getMethodName()).getActive();
            // Get the weight of the invoker's configuration. The default value is 100.
            int afterWarmup = getWeight(invoker, invocation);
            // save for later use
            weights[i] = afterWarmup;
            // If it is the first invoker or the active number of the invoker is less than the current least active number
            if (leastActive == -1 || active < leastActive) {
                // Reset the active number of the current invoker to the least active number
                leastActive = active;
                // Reset the number of least active invokers
                leastCount = 1;
                // Put the first least active invoker first in leastIndexes
                leastIndexes[0] = i;
                // Reset totalWeight
                totalWeight = afterWarmup;
                // Record the weight the first least active invoker
                firstWeight = afterWarmup;
                // Each invoke has the same weight (only one invoker here)
                sameWeight = true;
                // If current invoker's active value equals with leaseActive, then accumulating.
            } else if (active == leastActive) {
                // Record the index of the least active invoker in leastIndexes order
                leastIndexes[leastCount++] = i;
                // Accumulate the total weight of the least active invoker
                totalWeight += afterWarmup;
                // If every invoker has the same weight?
                if (sameWeight && afterWarmup != firstWeight) {
                    sameWeight = false;
                }
            }
        }
        // Choose an invoker from all the least active invokers
        if (leastCount == 1) {
            // If we got exactly one invoker having the least active value, return this invoker directly.
            return invokers.get(leastIndexes[0]);
        }
        if (!sameWeight && totalWeight > 0) {
            // If (not every invoker has the same weight & at least one invoker's weight>0), select randomly based on 
            // totalWeight.
            int offsetWeight = ThreadLocalRandom.current().nextInt(totalWeight);
            // Return a invoker based on the random value.
            for (int i = 0; i < leastCount; i++) {
                int leastIndex = leastIndexes[i];
                offsetWeight -= weights[leastIndex];
                if (offsetWeight < 0) {
                    return invokers.get(leastIndex);
                }
            }
        }
        // If all invokers have the same weight value or totalWeight=0, return evenly.
        return invokers.get(leastIndexes[ThreadLocalRandom.current().nextInt(leastCount)]);
    }
}

故障转移

//failover故障转移，轮询一遍所有执行器，直到执行器返回心跳成功为止
//否则返回失败
com.xxl.job.admin.core.route.strategy.ExecutorRouteFailover#route

忙碌转移

//failover故障转移，轮询一遍所有执行器，直到执行器返回心跳成功为止
//否则返回失败
com.xxl.job.admin.core.route.strategy.ExecutorRouteFailover#route

集群广播

SHARDING_BROADCAST

循环xxl_job_group 执行器列表，每个size
triggerParam.setBroadcastIndex(index);
triggerParam.setBroadcastTotal(total);

if (ExecutorRouteStrategyEnum.SHARDING_BROADCAST == executorRouteStrategyEnum) {
    if (index < group.getRegistryList().size()) {
        address = group.getRegistryList().get(index);
    } else {
        address = group.getRegistryList().get(0);
    }
}

triggerResult = runExecutor(triggerParam, address);

参考文档

http://dubbo.apache.org/zh-cn/docs/user/demos/loadbalance.html

grant167
关注
专栏目录
什么是负载均衡算法? 如何对负载均衡算法进行测试验证?
程序员光剑
09-18 1092
负载均衡（Load Balancing）是计算机网络系统设计中最常用的技术之一。它通过在服务器之间分配工作负载，使各台服务器都运行同样的任务，从而提高了整体处理能力、可用性及可伸缩性。本文将以实际案例的方式，为大家阐述什么是负载均衡算法，以及如何对负载均衡算法进行测试验证。负载均衡算法分为两类：静态调度算法（如轮询、加权轮询等）和动态调度算法（如基于心跳信号的动态转发算法等）。其中，动态调度算法能够在服务质量方面具有更好的抗风险能力。本文主要阐述基于HTTP协议的负载均衡算法。
负载均衡策略_策略路由在多线出口分流和负载均衡中的精妙应用
weixin_39943586的博客
12-09 1732
在网络运维中，经常会遇到多wan出口的网络，有时候静态路由和动态路由能解决一些问题，有时候却也无能为力，这个时候策略路由就成了最佳利器。下面就讲讲策略路由在各个场景下的应用。策略路由简单一些讲就是一种强制性路由，它可以将自定义的目标路由，目标协议，目标端口或源地址，源地址协议，源地址端口的组合强制从指定的wan口出去访问，策略路由在所有路由中优先级最高。通常配置在数据包入口，在路由器还没有查询路由...
链路负载均衡之策略路由
Mario_Ti的博客
03-06 1873
本文介绍链路负载均衡之策略路由，首先介绍策略路由的概念、从策略路由的组成、策略路由的匹配规则、策略路由的应用场景方面介绍，最后通过防火墙web界面以命令进行策略路由的配置。
关于策略路由实现负载均衡问题
weixin_34240520的博客
03-13 823
实验目的：R5的环回口lo0：5.5.5.5经过R3-R1到达R2，而环回口lo1：6.6.6.6经过R3-R4达到R2方法：在R3s0/0/0口设置策略路由达到对源IP5.5.5.5和6.6.6.6进行负载均衡配置：1、先配置所有路由器的接口IP和协议，使得能全网互ping 2、在R3上配置策略路由 在R3上show route-ma...
微服务注册与发现
康小虎的博客
08-05 304
上一篇我们讲了服务消费者去调用服务提供者，但是最后我们发现了一个问题，那就是对于请求地址的硬编码，那么我们接下来就学习Eureka这个服务发现组件。它有着强大的服务发现机制，服务消费者利用这种机制来获取服务提供者的网络信息，即使是服务提供者网络信息发生了变化，服务消费者也不需要修改自己的配置，这就解决了硬编码的问题。 服务提供者、服务消费者和服务发现组件的关系图： 服务提供者将自己的信息注...
【论文阅读】互连网络的负载平衡路由算法 (RLB & RLBth)
Messiah___的博客
04-24 1222
总结自A. Singh 的博士毕业论文。文章提出了用于 torus 网络的随机、非最小、不经意路由算法——**RLB和RLBth**
负载均衡原理及算法解析
最新发布
05-11
#### 二、常见负载均衡算法 **3. 轮询（Round Robin）** 轮询算法是最基础且最简单的负载均衡算法之一。在这种模式下，每个请求会被轮流分发到后端的服务器上。例如，如果有三台服务器A、B、C，则请求的分配顺序...
论文研究-基于负载均衡的Mesh路由算法研究与实现 .pdf
08-15
而负载均衡算法能够动态调整路由决策，通过合理分配数据包，使得网络资源得到更加合理的利用，提高网络吞吐量和数据转发成功率，并降低端到端的延迟。 传统的Mesh网络路由算法中，单路径算法由于其简单性，在实际...
面试官：什么是负载均衡？常见的负载均衡策略有哪些？
m0_71777195的博客
12-24 1055
负载均衡是云计算的基础组件，是网络流量的入口，其重要性不言而喻。什么是负载均衡呢？将用户请求或者说流量通过负载均衡器，按照某种负载均衡算法把流量均匀地分散到后端的多个服务器上，接收到请求的服务器可以独立的响应请求，以期望的规则分摊到多个操作单元上进行执行，达到负载分担的目的。并通过它可以实现横向扩展（scale out），将冗余的作用发挥为高可用。从应用场景上来说，常见的负载均衡模型有全局负载均衡和集群内负载均衡，从产品形态角度来说，又可以分为硬件负载均衡和软件负载均衡。
负载均衡算法常见问题与解决策略：全面解析，消除系统故障
常见的负载均衡算法包括轮询算法、加权轮询算法、最小连接算法等。这些算法根据不同的原则和特点，适用于不同的场景和需求。例如，轮询算法简单易用，适用于负载相对均衡的情况；加权轮询算法可以根据服务器的性能...
mwan3的代码和负载均衡的路由及iptables规则
03-13
1.mwan3的学习网址在https://mp.csdn.net/postedit/88431543 2.这里包括mwan3的代码、负载均衡生效后iptables的mangle表、以及IP路由的规则，供学习和参考
策略路由应用实例 多链路负载均衡技术
06-12
对于多链路负载均衡的路由器配置方法,非常简单,网工必需掌握的技术
论文阅读七：面向软件定义网络的负载均衡智能路由策略
weixin_43563178的博客
12-19 1365
名词解释： Machine Learning Aided Load Balance Routing Scheme Considering Queue Utilization, MLQU：考虑队列利用率的基于机器学习的负载均衡路由算法 QoS-oriented Adaptive Routing Scheme Based on Deep Reinforcement Learning, QAR：面向QoS的基于深度强化学习的自适应路由算法 Principal Component Analysis, PCA：
路由策略
qq_42905801的博客
03-07 377
基于控制层面流量（针对路由协议的流量）进行策略，最终影响路由表的生成，导致路径的选择被人为控制； 无论何种策略均需要一个协议来帮助其抓取流量； ACL-----1、数据层面流量的访问控制 2、定义感兴趣流量 前缀列表—专门用于为路由策略抓取网络号；可以为分发列表和route-map服务； 前缀列表 匹配规则：至上而下逐一匹配，若上条匹配按上条执行，不再查看下条；末尾隐含拒绝所有 路由策略是根据...
几种常见的路由负载均衡算法
jiangbinbin的博客
09-11 3981
package reg_fuzai.fuzai; import java.util.ArrayList; import java.util.HashMap; import java.util.Iterator; import java.util.List; import java.util.Map; import java.util.Set; import java.util.concurren...
策略路由和NAT实现负载均衡实例教程
Galdys的专栏
03-16 3747
一、组网需求： 1.正常情况下10.0.0.2从出口12.12.12.0NAT转化成100.0.0.0的地址，20.0.0.2从出口13.13.13.0NAT转化成200.0.0.0的地址，实现负载均衡。 2.FW双出口的某一条链路down，所有用户NAT成同一地址段出去，实现链路冗余。 二、实验组网 四、关键配置 USG5360 (V100R003C01
负载均衡原理及算法
KeaLoo
09-09 2699
目录背景概述原理分类按照软硬件分类硬件负载均衡软件负载均衡按照地理结构分类本地负载均衡全局负载均衡按照实现技术DNS负载均衡IP负载均衡链路层负载均衡混合型负载均衡按照OSI层次二层负载均衡（数据链路层）三层负载均衡（网络层）四层负载均衡（传输层）七层负载均衡（应用层）部署方式路由模式桥接模式服务直接返回模式常用算法轮询加权轮询IP哈希比率（Ratio）优先权（Priority）最少连接最快模式（Fastest）观察模式（Observed）预测模式（Predictive）动态性能分配(Dynamic Rat
路由策略概述
海绵汽水的博客
09-19 1297
路由策略原理        一个Route-Policy由多个节点构成，路由进入路由策略后，按节点序号从小到大依次检查各个节点是否匹配。一个节点包括多个if-match和apply子句。if-match子句用来定义该节点的匹配条件，apply子句用来定义通过过滤的路由行为。if-match子句的过滤规则关系是“与”，即该节点的所有if-match子句都必须匹配。Route-Policy节点间的过
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值