精华内容
下载资源
问答
  • 话不多说,直接上代码(本算法转载自“并发编程网 http://ifeve.com”)。   public class CycleAtomicInteger { private final static long PARK_TIME = 1000L * 1000; private AtomicInteger counter = new...

    话不多说,直接上代码(本算法转载自“并发编程网 http://ifeve.com”)。

     

    public class CycleAtomicInteger {
    private final static long PARK_TIME = 1000L * 1000;
    
    private AtomicInteger counter = new AtomicInteger(0);
    
    private int range;
    
    public CycleAtomicInteger(int range) {
        if (range < 2)
            throw new IllegalArgumentException();
        this.range = range;
    }
    
    /**
     * 获取下个原子值
     *
     * @return
     */
    public int next() {
        for (;;) {
            int c = counter.get();
            int next = (c + 1) % range;
            if (counter.compareAndSet(c, next)) {
                return c;
            } else {
                LockSupport.parkNanos(PARK_TIME);
            }
        }
    }
    
    }
    
    
    
    原文链接:(http://ifeve.com/13840/)
    
    展开全文
  • 2019年1月8日16:10:51 svn地址:svn://gitee.com/zxadmin/live_z 代码... <?... /* * 加权轮训算法 * * * $arr = array( array('id' => 'A', 'weight' => 3), array('id' => 'B', 'weight' => ...

    2019年1月8日16:10:51

    svn地址:svn://gitee.com/zxadmin/live_z    代码在code里面

    <?php
    
    /*
     * 加权轮训算法
     * 
     * 
     * $arr = array(
      array('id' => 'A', 'weight' => 3),
      array('id' => 'B', 'weight' => 3),
      array('id' => 'C', 'weight' => 6),
      array('id' => 'D', 'weight' => 4),
      array('id' => 'E', 'weight' => 1),
      );
     * $arr = array(
      array('id' => '192.168.1.1', 'weight' => 3),
      array('id' => '192.168.1.2', 'weight' => 3),
      array('id' => '192.168.1.3', 'weight' => 6),
      array('id' => '192.168.1.4', 'weight' => 4),
      array('id' => '192.168.1.5', 'weight' => 1),
      );
     */
    
    class ZxWeightedRoundRobin {
    
        private static $weightArray = array();
        private static $currentIndex = -1; //代表上一次选择的服务器
        private static $gcd; //表示集合S中所有服务器权值的最大公约数
        private static $currentWeight = 0; //当前调度的权值
        private static $maxWeight; //最大元素的值
        private static $count; //总元素个数
    
        public function __construct(array $weightArray) {
            self::$weightArray = $weightArray;
            self::$gcd = self::getGcd(self::$weightArray);
    //        p(self::$gcd);
        }
    
        /*
         * 
         * 算法的原理是:在服务器数组S中,首先计算所有服务器权重的最大值max(S),以及所有服务器权重的最大公约数gcd(S)。
          index表示本次请求到来时,选择的服务器的索引,初始值为-1;current_weight表示当前调度的权值,初始值为max(S)。
          当请求到来时,从index+1开始轮询服务器数组S,找到其中权重大于current_weight的第一个服务器,用于处理该请求。记录其索引到结果序列中。
          在轮询服务器数组时,如果到达了数组末尾,则重新从头开始搜索,并且减小current_weight的值:current_weight -= gcd(S)。如果current_weight等于0,则将其重置为max(S)。
         * 参考博客:https://blog.csdn.net/gqtcgq/article/details/52076997
         * https://blog.csdn.net/jjavaboy/article/details/45604569
         */
    
        public function getWeight() {
            while (true) {
                self::$currentIndex = ((int) self::$currentIndex + 1) % (int) self::$count;
                if (self::$currentIndex == 0) {
                    self::$currentWeight = (int) self::$currentWeight - (int) self::$gcd;
                    if (self::$currentWeight <= 0) {
                        self::$currentWeight = (int) self::$maxWeight;
                        if (self::$currentWeight == 0) {
                            return null;
                        }
                    }
                }
    //            p(self::$currentIndex);
                if ((int) (self::$weightArray[self::$currentIndex]['weight']) >= self::$currentWeight) {
                    return self::$weightArray[self::$currentIndex];
                }
            }
        }
    
        //获取最大公约数 Greatest common divisor  最大共同被除数
        private static function getGcd(array $weightArray) {
            if (empty($weightArray) || !is_array($weightArray)) {
                throw new \Exception('数组不能为空');
            }
            $weight = [];
            //权重只能为正整数
            foreach ($weightArray as $k => $v) {
                if (!is_int($v['weight']) || $v['weight'] <= 0) {
                    throw new \Exception('权限不合法');
                }
                $weight[] = $v['weight'];
            }
            $min = min($weight);
            self::$maxWeight = max($weight);
            self::$count = count($weight);
            //如果最小值是1,最小公约数就必定是1
            if ($min == 1) {
                return 1;
            }
            //如果不是1,就每个元素,循环查询对最小值往下做整除处理,如果全可以整除,如果有一个不能就中断
            for ($i = $min; $i > 1; $i--) {
                foreach ($weight as $k1 => $v1) {
                    if ($v1 % $i == 0) {
                        $status = true;
                    } else {
                        $status = false;
                        break;
                    }
                }
                if ($status) {
                    return $i;
                } else {
                    return 1;
                }
            }
        }
    
    }
    

    这个方法,我理解了最大公约数,但是 getWeight 方法还没有彻底理解,最小公约的话,就只需要修改 

    for ($i = $min; $i > 1; $i--) {遍历就可以

    测试调用方法
    $arr = array(
        array('id' => 'A', 'weight' => 3),
        array('id' => 'B', 'weight' => 3),
        array('id' => 'C', 'weight' => 6),
        array('id' => 'D', 'weight' => 4),
        array('id' => 'E', 'weight' => 2),
    );
    $weight = new ZxWeightedRoundRobin($arr);
    $a = 0;
    $b = 0;
    $c = 0;
    $d = 0;
    $e = 0;
    for ($j = 0; $j < 100; $j++) {
        $weightInfo = $weight->getWeight();
        print_r($weightInfo);
        echo $weightInfo['id'] . '----------------------weight:' . $weightInfo['weight'] . '<br/>';
        if ($weightInfo['id'] == 'A') {
            $a++;
        }
        if ($weightInfo['id'] == 'B') {
            $b++;
        }
        if ($weightInfo['id'] == 'C') {
            $c++;
        }
        if ($weightInfo['id'] == 'D') {
            $d++;
        }
        if ($weightInfo['id'] == 'E') {
            $e++;
        }
    }
    echo 'A:' . $a . '<br/>';
    echo 'B:' . $b . '<br/>';
    echo 'C:' . $c . '<br/>';
    echo 'D:' . $d . '<br/>';
    echo 'E:' . $e . '<br/>';
    exit;
    
     
    
    展开全文
  • 轮询调度算法

    千次阅读 2018-05-24 11:31:02
    轮询调度算法Java实现 1、轮询调度算法(Round-Robin Scheduling) 轮询调度算法的原理是每一次把来自用户请求轮流分配给内部中的服务器,从1开始,直到N(内部服务器个数),然后重新开始循环。 算法的优点是其...

    轮询调度算法Java实现

    1、轮询调度算法(Round-Robin Scheduling)

    轮询调度算法的原理是每一次把来自用户请求轮流分配给内部中的服务器,从1开始,直到N(内部服务器个数),然后重新开始循环。

    算法的优点是其简洁性,它无需记录当前所有连接的状态,所以它是一种无状态调度。

    轮询调度算法流程

    假设有一组服务器N台,S={S1,S2,…,Sn},一个指示变量i表示上一次选择的服务器ID。变量i被初始化为N-1。其算法如下:

    j=i;
        do {
            j=(i+1)mod n;
            i=j;
            return Si;
        }while(j!=i);
    return null;

    轮询调度算法假设所有服务器的处理性能都相同,不关心每台服务器的当前连接数和响应速度。当请求服务间隔时间变化较大时,轮询调度算法容易导致服务器间的负载不平衡。

    所以此种均衡算法适合于服务器组中的所有服务器都有相同的软硬件配置并且平均服务请求相对均衡的情况。

    2、权重轮询调度算法(Weighted Round-Robin Scheduling)

    上面所讲的轮询调度算法并没有考虑每台服务器的处理能力,在实际情况中,可能并不是这种情况。由于每台服务器的配置、安装的业务应用等不同,其处理能力会不一样。所以,我们根据服务器的不同处理能力,给每个服务器分配不同的权值,使其能够接受相应权值数的服务请求。

    权重轮询调度算法流程

    假设有一组服务器S={S0,S1,…,Sn-1},W(Si)表示服务器Si的权值,一个指示变量i表示上一次选择的服务器,指示变量cw表示当前调度的权值,max(S)表示集合S中所有服务器的最大权值,gcd(S)表示集合S中所有服务器权值的最大公约数。变量i初始化为-1,cw初始化为0。其算法如下:

    while(true){
        i=(i+1)mod n;
        if(i==0){
            cw=cw-gcd(S);
            if(cw<=0){
                cw=max(S);
                if(cw==0){
                    return NULL;
                }
            }
        }
        if(W(Si)>=cw){
            return Si;
        }
    }

    由于权重轮询调度算法考虑到了不同服务器的处理能力,所以这种均衡算法能确保高性能服务器得到更多的使用率,避免低性能的服务器负载过重。所以,在实际应用中比较常见。

    总结

    轮询调度算法以及权重轮询调度算法的特点是实现起来比较简洁,并且实用。目前几乎所有负载均衡设备均提供这种功能。

    JAVA实现

    /**   
     * @Title RoundRobinScheduling.java 
     * @Package com.shenh.arithmetic
     *
     * @Description 轮询调度算法(Round-Robin Scheduling)
     *
     * @author shenhuanjie 
     * @date 2018年1月15日 上午11:17:57
     *
     * @version v1.0 Copyright 2018
     */
    package com.shenh.arithmetic;
    import java.util.ArrayList;
    import java.util.List;
    /**
     * @ClassName RoundRobinScheduling
     *
     * @Description 轮询调度算法(Round-Robin Scheduling)
     *
     * @author shenhuanjie
     * @date 2018年1月15日 上午11:17:57
     *
     */
    public class RoundRobinScheduling {
    
           public static void main(String[] args) {
                  List<String> list = new ArrayList<String>();
                  list.add("1");
                  list.add("2");
                  list.add("3");
                  list.add("4");
                  list.add("5");
                  list.add("6");
                  list.add("7");
                  list.add("8");
                  list.add("9");
                  list.add("10");
                  list.add("11");
                  int n = list.size();
                  int i = n - 1;
                  for (int step = 0; step <= 100; step++) {
                         i = getRoundRobinScheduling(i, n);
                         System.out.println("N[" + i + "]=" + list.get(i));
                  }
           }
           private static int getRoundRobinScheduling(int i, int n) {
                  int j = i;
                  do {
                         j = (i + 1) % n;
                         i = j;
                  } while (j != i);
                  return i;
           }
    
    }
    
    /*output*/
    N[0]=1
    N[1]=2
    N[2]=3
    N[3]=4
    N[4]=5
    N[5]=6
    N[6]=7
    N[7]=8
    N[8]=9
    N[9]=10
    N[10]=11
    N[0]=1
    N[1]=2
    N[2]=3
    N[3]=4
    N[4]=5
    N[5]=6
    N[6]=7
    N[7]=8
    N[8]=9
    N[9]=10
    ...
    
    展开全文
  • haproxy的调度算法

    2019-11-05 21:02:51
    haproxy的调度算法 简介 HAProxy通过固定参数balance指明对后端服务器的调度算法,该参数可以配置在listen或backend选项中。 HAProxy的调度算法分为静态和动态调度算法,但是有些算法可以根据参数在静态和动态...

    haproxy的调度算法

    简介

    HAProxy通过固定参数balance指明对后端服务器的调度算法,该参数可以配置在listen或backend选项中。

    HAProxy的调度算法分为静态和动态调度算法,但是有些算法可以根据参数在静态和动态算法中相互转换

    https://cbonte.github.io/haproxy-dconv/2.0/configuration.html#4 #官方文档

    1)静态调度算法:

    • 静态算法:按照事先定义好的规则轮询公平调度,不关心后端服务器的当前负载、链接数和响应速度等,且无法实时修改权重,只能靠重启HAProxy生效。

    2)动态调度算法:

    • 基于后端服务器 状态进行调度适当调整,比如优先调度至当前负载较低的服务器,且权重可以在haproxy运行时动态调整无需重启。

    静态算法☞static-rr

    • static-rr:基于权重的轮询调度,不支持权重的运行时调整及后端服务器慢启动,其后端主机数量没有限制。
    • 配置:balance static-rr

    静态算法☞first

    • first:根据服务器在列表中的位置,自上而下进行调度,但是其只会当第一台服务器的连接数达到上限,新请求才会分配给下一台服务,因此会忽略服务器的权重设置。
    • 配置:balance first

    动态算法☞roundrobin

    • roundrobin:基于权重的轮询动态调度算法,支持权重的运行时调整,不完全等于lvs中的rr轮训模式,HAProxy中的roundrobin支持慢启动(新加的服务器会逐渐增加转发数),其每个后端backend中最多支持4095个realserver,roundrobin为默认调度算法,且支持对real server权重动态调整。
    • 配置:balance roundrobin

    动态算法☞leastconn

    • leastconn加权的最少连接的动态,支持权重的运行时调整和慢启动,即当前后端服务器连接最少的优先调度(新客户端连接),leastconn比较适合长连接的场景使用,比如MySQL等场景
    • balance leastconn

    其他算法☞source

    • 源地址hash,基于用户源地址hash并将请求转发到后端服务器,默认为静态即取模方式,但是可以通过hash-type支持的选项更改,后续同一个源地址请求将被转发至同一个后端web服务器,比较适用于session保持/缓存业务等场景。
    • 源地址有两种转发客户端请求到后端服务器的服务器选取计算方式,分别是取模法和一致性hash
    • 配置:
      balance source (默认是取模法)
      hash-type consistent hash类型:一致性hash
    取模法:

       map-based:取模法,基于服务器总权重的hash数组取模,该hash是静态的即不支持在线调整权重,不支持慢启动,其对后端服务器调度均衡,缺点是当服务器的总权重发生变化时,即有服务器上线或下线,都会因权重发生变化而导致调度结果整体改变。

       所谓取模运算,就是计算两个数相除之后的余数,10%7=3, 7%4=3,(2^32-1)%(1+1+2)。

    2)取模法示意图:

    一致性hash:

       一致性哈希,该hash是动态的,支持在线调整权重,支持慢启动,优点在于当服务器的总权重发生变化时,对调度结果影响是局部的,不会引起大的变动,hash(o)mod n。

       hash对象:

       一致性hash示意图:

    • 后端服务器在线与离线的调度方式

    其他算法☞uri

    • 基于对用户请求的uri做hash并将请求转发到后端指定服务器,也可以通过map-based和consistent定义使用取模法还是一致性hash。
    • 配置:
      balance uri
      hash-type consistent (uri 一致性hash)

    其他算法☞url_param

    • url_param对用户请求的url中的 params 部分中的参数name作hash计算,并由服务器总权重相除以后派发至某挑出的服务器;通常用于追踪用户,以确保来自同一个用户的请求始终发往同一个real server
    • 配置:balance url_param name,age #支持对单个及多个url_param值hash(注:一般取一个url_param 值hash,或者一般不使用)

    其他算法☞hdr

    • 针对用户每个http头部(header)请求中的指定信息做hash,此处由 name 指定的http首部将会被取出并做hash计算,然后由服务器总权重相除以后派发至某挑出的服务器,假如无有效的值,则会使用默认的轮询调度。
    • 配置:
      balance hdr(User-Agent)
      hash-type consistent

    其他算法☞rdp-cookie

    • rdp-cookie对远程桌面的负载,使用cookie保持会话
    • 配置:balance rdp-cookie
    基于iptables实现:
    • 注意:有去有回,iptables命令有两条
    net.ipv4.ip_forward = 1
    
    
    # iptables -t nat -A PREROUTING -d 192.168.7.101 -p tcp --dport 3389 -j DNAT --todestination 172.18.139.20:3389
    # iptables -t nat -A POSTROUTING -s 192.168.0.0/21 -j SNAT --to-source 192.168.7.101   
    

    其他算法☞random

    • 在1.9版本开始增加一个叫做random的负载平衡算法,其基于一个随机数作为一致性hash的key,随机负载平衡对于大型服务器场或经常添加或删除服务器非常有用,因为它可以避免在这种情况下由roundrobin或leastconn导致的锤击效应。
    • 配置:balance random

    算法总结

    first                       #使用较少
    
    
    static-rr                   #做了session共享的web集群
    roundrobin
    random
    
    
    leastconn                   #数据库
    source                      #基于客户端公网IP的会话保持
    
    
    Uri--------------->http     #缓存服务器,CDN服务商
    url_param--------->http 
    
    
    hdr                         #基于客户端请求报文头部做下一步处理
    
    
    rdp-cookie                  #很少使用
    
    • rdp-cookie 用于当未做session共享时,实现会话保持时使用rdp-cookie比源地址hash更好。但是一般情况下都会做session共享~~
    展开全文
  • lvs调度算法详解

    2019-09-27 17:00:11
    LVS调度算法分为静态类型和动态类型,共计10种: rr|wrr|lc|wlc|lblc|lblcr|dh|sh|sed|nq 常用的调度算法: 固定调度算法:rr,wrr,dh,sh 动态调度算法:wlc,lc,lblc,lblcr 算法 说明 ...
  • 通信 之 轮询调度算法

    千次阅读 2018-11-26 09:55:42
    Round-Robin Scheduling 常规轮训调度: https://blog.csdn.net/u011096710/article/details/51123104 加权轮询调度: https://blog.csdn.net/jasonliuvip/article/details/25725541
  • HAProxy调度算法

    2020-04-01 11:22:31
    文章目录HAProxy调度算法一、静态算法1.1:static-rr:1.2:first二、动态算法2.1:roundrobin2.2:leastconn三、其他算法3.1:source3.1.1:map-base取模法3.1.2:一致性hash3.2:uri3.2.1:uri 取模法配置示例...
  • Linux内核调度框架和CFS调度算法

    千次阅读 2019-02-15 14:10:12
    进程调度 暂时以2.6.24内核版本讲解,该版本是CFS调度器注入Linux内核之后的第二个版本,在框架和数据结构上与4.x之后...主要讲解CFS调度类与调度框架,实时进程与其他类型的进程调度算法与CFS在框架上没有区...
  • HAProxy调度算法总结

    2021-09-13 12:44:24
    调度算法 使用的协议 算法描述 静态算法 static-rr tcp/http 基于权重的轮询调度,不支持运行时利用socat进行权重的动态调整(只支持0和1,不支持其它值)及后端服务器慢启动,其后端主机数量没有限制...
  • 权重轮询调度算法 java版本

    千次阅读 2014-05-09 17:23:26
    权重轮询调度算法(Weighted Round-Robin Scheduling)--java版本。 由于权重轮询调度算法考虑到了不同服务器的处理能力,所以这种均衡算法能确保高性能的服务器得到更多的使用率,避免低性能的服务器负载过重。
  • 实现一个简单负载均衡调度算法,支持随机、轮训、hash等算法 package balance import{ "errors" "math/rand" } type Instance struct{ host string port int } func NewInstance(host string, port int) *...
  • 说到进程调度,还是很难说清楚的问题,网上的文章虽然汗牛充栋,但我觉得缺少重点且篇幅比较冗余。我争取抓住重点,以较短的篇幅讲清楚。1、进程优先级和分类进程优先级代表进程需要运行的紧急程度和需要更多的运行...
  • HAProxy(三)调度算法

    2019-08-23 09:10:37
    文章目录HAProxy调度算法一、静态算法1. static-rr2. first二、动态算法:1. roundrobin2. leastconn三、混合算法1. source2. uri3. url_param:4. hdr5. rdp-cookie6. random4层与7层的区别IP透传:四层IP透传七层...
  • nginx四种调度算法、进阶

    千次阅读 2017-11-06 13:08:44
    upstream 支持4种负载均衡调度算法:A)轮询(默认):每个请求按时间顺序逐一分配到不同的后端服务器;B)ip_hash:每个请求按访问IP的hash结果分配,同一个IP客户端固定访问一个后端服务器;C)url_hash:按访问url的hash结果...
  • HAparoxy《一》——基础介绍以及安装 HAProxy调度算法 ...HAProxy通过固定参数balance指明对后端服务器的调度算法,该参数可以配置在listen或...HAProxy的调度算法分为静态和动态调度算法,但是有些算法可以根据参...
  • haproxy 调度算法 HAproxy通过固定参数balance指明对后端服务器的调度算法,该参数可以配置在listen或backend选项中 HAproxy的调度算法分为静态和动态算法,但是有些算法可以根据参数在静态和动态算法中相互转换 #...
  • verilog的RR轮询调度算法的代码实现

    千次阅读 2020-07-21 15:22:45
    大神们,求一份verilog的RR轮询调度算法的代码实现。跪谢
  • 轮询调度算法(Round-Robin Scheduling)

    万次阅读 2014-05-13 17:11:48
    轮询调度算法(Round Robin Scheduling)算法就是以循环的方式依次将请求调度不同的服务器,即每次调度执行i = (i + 1) mod n,并选出第i台服务器。算法的优点是其简洁性,它无需记录当前所有连接的状态,所以它是一...
  • 在多台机器实现负载均衡的时候,经常用到轮询调度算法(Round-Robin Scheduling)。 轮询调度算法就是:以循环的方式,依次将请求调度到不同的服务器,即每次调度执行i = (i + 1) mod n,并选出第i台服务器。 算法的...
  • CPU调度及其算法

    万次阅读 2018-05-19 15:03:05
    CPU调度:即按一定的调度算法从就绪队列中选择一个进程,把CPU的使用权交给被选中的进程,如果没有就绪进程,系统会安排一个系统空闲进程或idle进程。 CPU调度时机:发生在内核对中断/异常/系统调用处理后返回到...
  • 负载均衡之权重轮询调度算法

    万次阅读 2016-11-09 16:52:04
    负载均衡之权重轮询调度算法 一、负载均衡  nginx不单可以作为强大的web服务器,也可以作为一个反向代理服务器。如果nginx是以反向代理的形式配置运行,那么对请求的实际处理需要转发到后端服务器运行,如果后端...
  • 权重轮询调度算法(Weighted Round-Robin Scheduling)&gt;&gt;这篇文章写了一个golang版本的权重轮询调度算法,请大家指教,不多说了直接上代码: package main import ( "fmt" "time&...
  • //当前调度的权值 private static $_max; private static $_n;//agent个数 public function __construct(array $weightArray) { self::$_weightArray = $weightArray; self::$_gcd = self::getGcd...
  • 更多go语言、区块链、后端、架构等内容,公众号(Go语言之美)持续更新关于操作系统是如何虚拟化 CPU 的我们上一篇文章已经聊过了,今天再深入一下,聊一聊进程调度那些事。我们已经知道,对 CPU 虚拟化的目的就是能够...
  • 2017年1月12日, 星期四LVS原理详解(3种工作模式及8种调度算法) LVS原理详解及部署之二:LVS原理详解(3种工作方式8种调度算法)作者:woshiliwentong 发布日期:2014-01-06 09:31:20一、集群简介什么是集群...
  • LVS工作原理可以简单理解为: Lvs工作在内核空间,本身工作在input链上,与iptable不能同时用。 LVS: ipvsadm :管理集群...进一步了解当调度端接受法向真实的服务器的数据包发生了什么 通过内核的数据包,内核将
  • 调度策略是核心路由交换设备性能的重要保证.针对联合输入交叉节点排队(combined input and cross-point queuing,简称CICQ)交换结构现有调度策略在复杂度或性能方面存在的缺陷,深入探讨了CICQ 交换结 构调度策略设计...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,749
精华内容 699
关键字:

轮训调度算法