精华内容
下载资源
问答
  • 轮询调度算法

    千次阅读 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
    ...
    
    展开全文
  • 加权轮询调度算法DWRR

    2018-11-19 23:36:37
    权重轮询调度算法(WeightedRound-RobinScheduling)-matlab实现
  • 通信 之 轮询调度算法

    千次阅读 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
    展开全文
  • 主要介绍了PHP 进程池与轮询调度算法实现多任务的示例代码,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • Round Robin 轮询调度算法 轮询调度(Round-Robin Scheduling) 轮询调度(Round Robin Scheduling)算法就是以轮询的方式依次将请求调度不同的服务器,即每次调度执行i = (i + 1) mod n,并选出第i台服务器。算法的...

    Round Robin 轮询调度算法

    轮询调度(Round-Robin Scheduling)

    轮询调度(Round Robin Scheduling)算法就是以轮询的方式依次将请求调度不同的服务器,即每次调度执行i = (i + 1) mod n,并选出第i台服务器。算法的优点是其简洁性,它无需记录当前所有连接的状态,所以它是一种无状态调度。

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

    轮询调度算法流程

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

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

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

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

    展开全文
  • c语言实现时间片轮询调度

    千次阅读 2019-05-30 23:03:59
    时间片轮询调度法模拟 #include<stdio.h> #define MAX 10 struct task_struct { char name[10]; /进程名称/ int number; /进程编号/ float come_time; /到达时间/ float run_begin_time; /开始运行时间...

    时间片轮询调度法模拟

    #include<stdio.h>
    #define MAX 10
    struct task_struct
    {
    char name[10]; /进程名称/
    int number; /进程编号/
    float come_time; /到达时间/
    float run_begin_time; /开始运行时间/
    float run_time; /运行时间/
    float run_end_time; /运行结束时间/
    int priority; /优先级/
    int run_flag; /调度标志/
    int start_flag; //是否为第一次开始调度
    } tasks[MAX];
    int counter; /实际进程个数/
    int time_counter=0;
    int poutput(); /调度结果输出/
    int time();
    int charge();//判断是否所有的进程都被执行过

    void main()
    {

    pinput();
    printf("时间片轮转算法。\n\n");
    time();
    poutput();
    

    }

    int time()
    {
    float time_temp=0;
    int i;
    int j=0;
    int k=0;

    struct task_struct  copy_task[MAX];//备份
    for(i=0; i<counter; i++)
    {
        copy_task[j++]=tasks[i];//对进程的初始化信息备份
    }
    
    time_temp=tasks[0].come_time;
    while(charge())
    {
        for(i=0; i<counter; i++)
        {
            if(tasks[i].come_time>time_temp)
            {
                time_temp=tasks[i].come_time;
            }
            if(tasks[i].run_flag==0)//该进程还未结束
            {
                if(tasks[i].start_flag==0)  //该条件成立则说明,该进程是第一次执行,记录开始执行时间
                {
                    tasks[i].run_begin_time=time_temp;
                    tasks[i].start_flag=1;
                }
                if(tasks[i].run_time/time_counter>1)//至少有两倍的时间片未执行
                {
                    tasks[i].run_time=tasks[i].run_time-time_counter;
                    time_temp=time_temp+time_counter;
                }
                else if(tasks[i].run_time-time_counter==0)
                {
                    time_temp=time_temp+time_counter;
                    tasks[i].run_end_time=time_temp;
                    tasks[i].run_flag=1;
                    tasks[i].run_time=copy_task[i].run_time;
                }
                else//仅剩下不足一倍的时间片
                {
                    time_temp=time_temp+tasks[i].run_time;
                    tasks[i].run_end_time=time_temp;
                    tasks[i].run_flag=1;
                    tasks[i].run_time=copy_task[i].run_time;
                }
            }
        }
    }
    

    }

    int charge()//判断是否全部进程都执行完毕
    {
    int k;
    int super_flag=0;//判断是否全部的进程都执行完毕
    for(k=0; k<counter; k++)
    {
    if(tasks[k].run_flag==0)
    {
    super_flag=1;
    return super_flag;
    break;
    }
    else
    {
    super_flag=0;
    }
    }
    return super_flag;
    }

    int pinput() /进程参数输入/
    {
    int i;
    printf(“please input the process counter:\n”);
    scanf("%d",&counter);
    printf(“please input the length of time:\n”);
    scanf("%d",&time_counter);
    for(i=0; i<counter; i++)
    {
    printf("******************************************\n");
    printf(“please input the process of %d th :\n”,i+1);
    printf(“please input the name:\n”);
    scanf("%s",tasks[i].name);
    printf(“please input the number:\n”);
    scanf("%d",&tasks[i].number);
    printf(“please input the come_time:\n”);
    scanf("%f",&tasks[i].come_time);
    printf(“please input the run_time:\n”);
    scanf("%f",&tasks[i].run_time);
    printf(“please input the priority:\n”);
    scanf("%d",&tasks[i].priority);
    tasks[i].run_begin_time=0;
    tasks[i].run_end_time=0;
    tasks[i].run_flag=0; //运行是否结束
    tasks[i].start_flag=0;//是否首次被执行
    }
    return 0;
    }

    int poutput() /调度结果输出/
    {
    int i;
    float turn_round_time=0,f1,w=0;
    printf(“进程名 进程号 到达时间 运行时间 开始时间 结束时间 优先级 周转时间\n”);
    for(i=0; i<counter; i++)
    {
    f1=tasks[i].run_end_time-tasks[i].come_time;
    turn_round_time+=f1;
    printf("%s\t%d\t%5.3f\t%5.3f\t%5.3f\t %5.3f\t %d\t %5.3f\n",tasks[i].name,tasks[i].number,tasks[i].come_time,tasks[i].run_time,tasks[i].run_begin_time,tasks[i].run_end_time,tasks[i].priority,f1);
    }
    printf(“average_turn_round_timer=%5.2f\n”,turn_round_time/counter);
    return 0;
    }

    展开全文
  • ATmega128时间片轮询调度算法,可以模拟实现RTOS多任务功能,很好移植,代码量小
  • 轮询调度算法 Round Robin

    千次阅读 2020-05-08 22:31:06
    最近重温了下nginx,看到负载均衡调度算法默认是round robin,也就是轮询调度算法。 算法本身很简单,轮着一个一个来,非常简单高效公平的调度算法。 简单的算法实现: int datas = [1, 2, 3, 4, 5]; int size = 5; ...
  • Round-robin 轮询调度详解

    千次阅读 2017-12-20 16:17:08
    先来看和他相近的名词,轮询调度算法(Round-Robin Scheduling) 轮询调度算法的原理是每一次把来自用户的请求轮流分配给内部中的服务器,从1开始,直到N(内部服务器个数),然后重新开始循环。 算法的优点是其...
  • 权重轮询调度算法 java版本

    千次阅读 2014-05-09 17:23:26
    权重轮询调度算法(Weighted Round-Robin Scheduling)--java版本。 由于权重轮询调度算法考虑到了不同服务器的处理能力,所以这种均衡算法能确保高性能的服务器得到更多的使用率,避免低性能的服务器负载过重。
  • 线程的时间片轮询调度 优先级和时间片是线程的两个重要参数,分别描述了线程竞争处理器资源的能力和持有处理器时间长短的能力。 线程优先级 RT-Thread最大支持256个优先级(数值越小的优先级越高,0为最高优先级,...
  • 先来看和他相近的名词,轮询调度算法(Round-Robin Scheduling)轮询调度算法的原理是每一次把来自用户的请求轮流分配给内部中的服务器,从1开始,直到N(内部服务器个数),然后重新开始循环。算法的优点是其简洁性,它...
  • verilog的RR轮询调度算法的代码实现

    千次阅读 2020-07-21 15:22:45
    大神们,求一份verilog的RR轮询调度算法的代码实现。跪谢
  • 这是一个能在PIC16F877A开发板上运行的固定时间片轮询调度汇编程序代码。 为什么要用时间片轮询调度? 假如我们要写一个单片机程序,程序的目的就是用GPIO控制一个灯亮一秒再暗一秒…最简单的写法是用循环来计时,...
  • 轮询调度算法是负载均衡技术实现中的核心技术,也是负载均衡设备中的核心实现基础 [b]1:轮询调度算法(Round-Robin Scheduling)[/b] 轮询调度算法的原理是每一次把来自用户的请求轮流分配给内部中的服务器,从1开始...
  • 在多台机器实现负载均衡的时候,经常用到轮询调度算法(Round-Robin Scheduling)。 轮询调度算法就是:以循环的方式,依次将请求调度到不同的服务器,即每次调度执行i = (i + 1) mod n,并选出第i台服务器。 算法的...
  • 权重轮询调度算法(WeightedRound-RobinScheduling)-Java实现3 之前两篇相关博文: 权重轮询调度算法(WeightedRound-RobinScheduling)-Java实现 http://www.cnblogs.com/huligong1234/p/3819979.html 权重轮询调度...
  • 负载均衡之权重轮询调度算法

    万次阅读 2016-11-09 16:52:04
    负载均衡之权重轮询调度算法 一、负载均衡  nginx不单可以作为强大的web服务器,也可以作为一个反向代理服务器。如果nginx是以反向代理的形式配置运行,那么对请求的实际处理需要转发到后端服务器运行,如果后端...
  • LVS 轮询调度详解

    2020-12-15 14:57:06
    固定调度算法:rr,wrr,dh,sh 动态调度算法:wlc,lc,sed,nq,lblc,lblcr ...轮询算法假设所有的服务器处理请求的能力都是一样的,调度器会将所有的请求平均分配给每个真实服务器,不管后端 RS
  • 调度策略是核心路由交换设备性能的重要保证.针对联合输入交叉节点排队(combined input and cross-point queuing,简称CICQ)交换结构现有调度策略在复杂度或性能方面存在的缺陷,...效和公平服务的动态轮询调度策略——FDR
  • 今天做亚信的笔试题遇到的轮询调度算法,和春招做的百度笔试题短作业优先调度算法很相似,但是难度要UPUP。做题的过程中,因为没有正确地处理迭代器失效的问题浪费了好多时间(>﹏ 轮询调度算法 如果一个系统可以...
  • import java.util.ArrayList; import java.util.Date; import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.Map.... * 权重轮询调度算法(WeightedRound-RobinScheduling)-Ja
  • vue vuex 轮询调度

    2019-09-27 19:41:44
    1.store中定义轮询模块 export default new Vuex.Store...页面轮询:仅单独页面的轮询,离开页面则取消轮询全局轮询:项目启动便一直存在原理:轮询模块中的state变量有定时器变量以及轮询数据 const state = ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 55,110
精华内容 22,044
关键字:

轮询调度