精华内容
下载资源
问答
  • C语言编写的操作系统作业--模拟进程调度 优先级算法
  • 使用C模拟的操作系统以优先级为标准调度进程算法进程调度一次优先级减1,同时剩余运行时间减1
  • 计算机操作系统 进程调度模拟算法 算法实现方法:最短时间算法,时间片轮转算法,优先级算法,C语言算法实现
  • 进程调度模拟设计——优先级法、最高响应比优先调度算法
  • 操作系统进程调度中,优先级调度算法模拟,模拟进程调度,采用优先级调度算法,非抢占式,资源分配,资源分配。
  • 进程优先级调度算法

    2018-06-22 18:49:01
    《计算机与操作系统(第四版)》进程优先级调度算法 1.时间片轮转调度算法 2.多级反馈队列调度算法 3.高响应比优先调度算法
  • 进程调进程调度算法进程调度算法进程调度算法进程调度调度算法进程调度算法进程调度算法
  • 操作系统实验课程中进程优先级调度算法利用C语言实现程序
  • 进程调度优先级

    2020-06-24 15:16:41
    Linux内核的三种调度策略: ...放在队列尾保证了所有具有相同优先级的RR任务的调度公平 Linux线程优先级设置: 首先,可以通过以下两个函数来获得线程可以设置的最高和最低优先级,函数中的策略即...

    Linux内核的三种调度策略:

        1.SCHED_OTHER 分时调度策略

        2.SCHED_FIFO  实时调度策略,先到先服务。一旦占用cpu则一直运行。一直运行直到有更高优先级任务到达或自己放弃

        3.SCHED_RR实  时调度策略,时间片轮转。当进程的时间片用完,系统将重新分配时间片,并置于就绪队列尾。放在队列尾保证了所有具有相同优先级的RR任务的调度公平

    Linux线程优先级设置:

        首先,可以通过以下两个函数来获得线程可以设置的最高和最低优先级,函数中的策略即上述三种策略的宏定义:

      int sched_get_priority_max(int policy);
      int sched_get_priority_min(int policy);

    注意:SCHED_OTHER 是不支持优先级使用的,而 SCHED_FIFO 和 SCHED_RR 支持优先级的使用,他们分别为1和99,数值越大优先级越高。(用户态下)

        设置和获取优先级通过以下两个函数:

    int pthread_attr_setschedparam(pthread_attr_t *attr, const struct sched_param *param);
    int pthread_attr_getschedparam(const pthread_attr_t *attr, struct sched_param *param);
      param.sched_priority = 51; //设置优先级

        系统创建线程时,默认的线程是 SCHED_OTHER。所以如果我们要改变线程的调度策略的话,可以通过下面的这个函数实现。

    int pthread_attr_setschedpolicy(pthread_attr_t *attr, int policy);

        上面的param使用了下面的这个数据结构:

    struct sched_param
    {
        int __sched_priority; // 所要设定的线程优先级
    };

        我们可以通过下面的测试程序来说明,我们自己使用的系统的支持的优先级:

    复制代码

    #include <stdio.h>
    #include <pthread.h>
    #include <sched.h>
    #include <assert.h>
    
    static int api_get_thread_policy (pthread_attr_t *attr)
    {
        int policy;
        int rs = pthread_attr_getschedpolicy (attr, &policy);
        assert (rs == 0);
    
        switch (policy)
        {
            case SCHED_FIFO:
                printf ("policy = SCHED_FIFO\n");
                break;
            case SCHED_RR:
                printf ("policy = SCHED_RR");
                break;
            case SCHED_OTHER:
                printf ("policy = SCHED_OTHER\n");
                break;
            default:
                printf ("policy = UNKNOWN\n");
                break; 
        }
        return policy;
    }
    
    static void api_show_thread_priority (pthread_attr_t *attr,int policy)
    {
        int priority = sched_get_priority_max (policy);
        assert (priority != -1);
        printf ("max_priority = %d\n", priority);
        priority = sched_get_priority_min (policy);
        assert (priority != -1);
        printf ("min_priority = %d\n", priority);
    }
    
    static int api_get_thread_priority (pthread_attr_t *attr)
    {
        struct sched_param param;
        int rs = pthread_attr_getschedparam (attr, &param);
        assert (rs == 0);
        printf ("priority = %d\n", param.__sched_priority);
        return param.__sched_priority;
    }
    
    static void api_set_thread_policy (pthread_attr_t *attr,int policy)
    {
        int rs = pthread_attr_setschedpolicy (attr, policy);
        assert (rs == 0);
        api_get_thread_policy (attr);
    }
        
    int main(void)
    {
        pthread_attr_t attr;       // 线程属性
        struct sched_param sched;  // 调度策略
        int rs;
    
        /* 
         * 对线程属性初始化
         * 初始化完成以后,pthread_attr_t 结构所包含的结构体
         * 就是操作系统实现支持的所有线程属性的默认值
         */
        rs = pthread_attr_init (&attr);
        assert (rs == 0);     // 如果 rs 不等于 0,程序 abort() 退出
    
        /* 获得当前调度策略 */
        int policy = api_get_thread_policy (&attr);
    
        /* 显示当前调度策略的线程优先级范围 */
        printf ("Show current configuration of priority\n");
        api_show_thread_priority(&attr, policy);
    
        /* 获取 SCHED_FIFO 策略下的线程优先级范围 */
        printf ("show SCHED_FIFO of priority\n");
        api_show_thread_priority(&attr, SCHED_FIFO);
    
        /* 获取 SCHED_RR 策略下的线程优先级范围 */
        printf ("show SCHED_RR of priority\n");
        api_show_thread_priority(&attr, SCHED_RR);
    
        /* 显示当前线程的优先级 */
        printf ("show priority of current thread\n");
        int priority = api_get_thread_priority (&attr);
    
        /* 手动设置调度策略 */
        printf ("Set thread policy\n");
    
        printf ("set SCHED_FIFO policy\n");
        api_set_thread_policy(&attr, SCHED_FIFO);
    
        printf ("set SCHED_RR policy\n");
        api_set_thread_policy(&attr, SCHED_RR);
    
        /* 还原之前的策略 */
        printf ("Restore current policy\n");
        api_set_thread_policy (&attr, policy);
    
        /* 
         * 反初始化 pthread_attr_t 结构
         * 如果 pthread_attr_init 的实现对属性对象的内存空间是动态分配的,
         * phread_attr_destory 就会释放该内存空间
         */
        rs = pthread_attr_destroy (&attr);
        assert (rs == 0);
    
        return 0;
    }

    复制代码

     

    下面是测试程序的运行结果:

    复制代码

    policy=SCHED_OTHER
    Show current configuration of priority
    max_priority=0
    min_priority=0
    show SCHED_FIFO of priority
    max_priority=99
    min_priority=1
    show SCHED_RR of priority
    max_priority=99
    min_priority=1
    show priority of current thread
    priority=0Set thread policy
    set SCHED_FIFO policy
    policy= SCHED_FIFO
    set SCHED_RR policy
    policy= SCHED_RRRestore current policy
    policy=SCHED_OTHER

    复制代码

    ------------------------------------------------------------------------------------------------------------------------------------------------------------------------

    linux 实时线程优先级问题——数值越大优先级越高吗?  

    2012-06-03 15:14:23|  分类: linux内核开发 |字号 订阅

         今天查看了linux下的实时线程,FIFO和RR策略的调度,遇到一个问题:

         priority越大优先级越高呢?还是越小越高呢?

         回答这个问题要明白一个问题,首先,linux2.6内核将任务优先级进行了一个划分:

        0——99  实时进程 

       100——139   非实时进程

        现在,这个划分是起决定作用的,而且一定是数值越小,优先级越高。

        但是,有时候从网上会看到 优先级数值越大,优先级越高?这又是怎么回事?难道有一种说法错了吗?

       实际的原因是这样的,对于一个实时进程,他有两个参数来表明优先级——prio 和 rt_priority,

       prio才是调度所用的最终优先级数值,这个值越小,优先级越高;

       而rt_priority 被称作实时进程优先级,他要经过转化——prio=MAX_RT_PRIO - 1- p->rt_priority; 

       MAX_RT_PRIO = 99;这样意味着rt_priority值越大,优先级越高;

       而内核提供的修改优先级的函数(pthread_attr_setschedparam),是修改rt_priority的值,所以越大,优先级越高

       所以用户在使用实时进程或线程,在修改优先级时,就会有“优先级值越大,优先级越高的说法”,也是对的。

     

    http://bbs.chinaunix.net/thread-1996337-1-1.html
                    关于进程时间片的计算
        进程的时间片time_slice是基于进程静态优先级的。
        静态优先级越高(值越小),时间片就越大。
        计算时间片是通过函数task_timeslice()(kernel/sched.c)来完成的。
        通过优先级来计算时间片的等式为:
            timeslice=MIN_TIMESLICE+((MAX_TIMESLICE-MIN_TIMESLICE)*(MAX_PRIO-1-(p)->static_prio)/(MAX_USER_PRIO-1))
        这样的话就可以将100~139 的优先级映射到200ms~10ms 的时间片上去,优先级数值越大,则分配的时间片越小。
    在Kernel2.6中时间片的计算是分散的,具体的计算既可以用task_timeslice(),也可以用其他方法。
        进程创建时,将父进程的时间片分一半给子进程,同时父进程的时间片减半。
        进程用完时间片以后,需要重新计算时间片,并将进程插入到相应的运行队列。
        进程退出时,根据first_timeslice的值来决定是否将子进程的时间片返还给父进程。
    平均等待时间sleep_avg
        平均等待时间sleep_avg既决定了进程优先级,又影响了进程交互程度。
        进程的平均等待时间(以nanosecond 为单位),在0 到NS_MAX_SLEEP_AVG 之间取值,初值为0。
        这个值是动态优先级计算的关键因子,sleep_avg 越大,计算出来的进程优先级也越高(数值越小)。

    ------------------
       ------------------------------------------------------------------------------------------------------------------------------------------------------------------------

    chrt命令:修改进程的调度策略和优先级

    宋宝华: 关于Linux进程优先级数字混乱的彻底澄清 

            Linux进程的调度优先级数字会在好几个地方出现:内核,用户,top命令。他们各自都有自己的表示法。我们用一个实际的例子来说明,下面在Linux写一个最简单的程序:

    编译它运行,把调度策略设置为SCHED_FIFO,优先级设置为50:$ sudo chrt -f 50 ./a.out这个时候我们在top命令里面观察a.out:

    我们看到a.out的PR(优先级是)-51,CPU利用率100%。
    但是从内核的视角上面来看,又会用99减去用户在chrt里面设置的优先级:


    上面的MAX_RT_PRIO的值为:

     

    所以上述进程的优先级,在三个不同视角的值分别为:

    用户

    内核

    Top

    50

    49

    -51

     

    咋回事

    Linux的RT调度策略和普通进程在调度算法上面有差异,RT的SCHED_FIFO和SCHED_RR采用的是一个bitmap:

    每次从第0bit开始往后面搜索第一个有进程ready的bit,然后调度这个优先级上面的进程执行,所以在内核里面,prio数值越小,优先级越高
    但是从用户态的API里面,则是数值越大,优先级越高。下面的代码,一个线程通过调用API把自己设置为SCHED_FIFO,优先级50

    这个上面的50,对应内核的49。如果我们把优先级设置为51:

    这个51,对应内核bitmap上面的48。所以,你会发现,从用户的视角来看,数值变大,优先级变高。上面这2个视角,都不是top命令的视角。对于RT的进程而言,TOP的视角里面的PR= -1 -用户视角譬如,下面用户视角的88

    $ sudo chrt -f 88 ./a.out

    对应内核视角的11,对应top视角的-89

    这实在让人有一点晕!!
    这里还有一个特例,就是用户视角的99(内核bitmap视角的0),显示为top命令的RT:

    这说明一点,只有最高优先级的RT进程,才在top里面显示为rt。

    普通的呢?

    普通的讲nice的人相对来说比较简单,我们更关注它的nice值,-20~19之间,nice越低,优先级越高,权重越大,在CFS的红黑树左边的机会大。

    你发现.nice为5的进程,在top命令显示PR是25。下面我们看nice是-5的:

    它显示的是PR=15。由此大家可以发现规律,对于普通的采用CFS策略的NORMAL进程,top里面的PR=20+NICE

    在一起

    总结一下,4个例子

    用户

    内核

    Top

    RT 50

    49 (99-50)

    -51 (-1-50)

    RT 99

    rt

    NICE 5

     

    25

    NICE -5

     

    15

    由此发现,在top里面,RT策略的PR都显示为负数;最高优先级的RT,显示为rt。top命令里面也是,数字越小,优先级越高。

     

    展开全文
  • 模拟进程优先级调度算法,是进程调度模拟程序中的一种实现算法
  • 进程调度优先级算法分析(C++实现)

    千次阅读 2020-10-28 22:22:42
    1. 优先权调度算法 为了照顾紧迫型进程获得优先处理,引入了优先权调度算法。它从就绪队列中选择一个优先权最高的进程,让其获得处理器并执行。这时,又进一步把该算法分为两种方式: 1)非抢占式优先权调度算法 在...

    1. 优先权调度算法 照顾紧迫型进程获得优先处理,引入了优先权调度算法。它从就绪队列中选择一个优先权最高的进程,让其获得处理器并执行。这时,又进一步把该算法分为两种方式:

    1)非抢占式优先权调度算法 在这种方式下,系统一旦把处理器分配给就绪队列中优先权最高的进程后,该进程就占有处理器一直运行下去,直到该进程完成或因发生事件而阻塞,才退出处理器。系统这时才能将处理器分配给另一个优先权高的进程。这种方式实际上是每次将处理器分配给当前就绪队列中优先权最高的进程。它常用于批处理系统中,也可用于某些对时间要求不严格的实时系统中。

    2)抢占式优先权调度算法 在这种方式下,系统同样把处理器分配给当前就绪队列中优先权最高的进程,使之执行。但在其执行期间,仍然会不断有新的就绪进程进入就绪队列,如果出现某个进程,其优先权比当前正在执行的进程的优先权还高时,进程调度程序就会立即暂停当前进程的执行,而将 处理器收回,并将处理器分配给新出现的优先权更高的进程,让其执行。这种方式实际上永 远都是系统中优先权最高的进程占用处理器执行。因此,它能更好地满足紧迫进程的要求, 故常用于要求比较严格的实时系统中,以及对性能要求较高的批处理和分时系统中。

    对于优先权调度算法,其关键在于是采用静态优先权,还是动态优先权,以及如何确定 进程的优先权。

    1) 静态优先权 静态优先权是在创建进程时确定的,并且规定它在进程的整个运行期间保持不变。一般来说,优先权是利用某个范围内的一个整数来表示的,如 0~7,或 0~255 中的某个整数, 所以又称为优先数。在使用时,有的系统用“0”表示最高优先权,数值越大优先权越小, 而有的系统则恰恰相反

    2) 动态优先权 动态优先权要配合抢占调度方式使用,它是指在创建进程时所赋予的优先权,可以随着进程的推进而发生改变,以便获得更好的调度性能。在就绪队列中等待调度的进程,可以随 着其等待时间的增加,其优先权也以某个速率增加。因此,对于优先权初值很低的进程,在 等待足够长的时间后,其优先权也可能升为最高,从而获得调度,占用处理器并执行。同样 规定正在执行的进程,其优先权将随着执行时间的增加而逐渐降低,使其优先权可能不再是 最高,从而暂停其执行,将处理器回收并分配给其他优先权更高的进程。这种方式能防止一 个长进程长期占用处理器的现象。

    程序示例:

    1. 本程序用两种算法对五个进程进行调度,每个进程可有三种状态,并假设初始状态为就 绪状态。

    2. 为了便于处理,程序中的某进程运行时间以时间片为单位计算。各进程的优先数或轮转 时间数以及进程需运行的时间片数的初始值均由用户给定。

    3. 在优先数算法中,优先数可以先取值为 50,进程每执行一次,优先数减 3CPU 时间片 数加 1,进程还需要的时间片数减 1

    #include<stdio.h>
    #include <dos.h>
    #include<stdlib.h>
    #include<conio.h>
    #include<iostream>
    using namespace std;
    #include<windows.h>
    #define P_NUM 5   //进程数
    #define P_TIME 50 //优先数预先取值为50
    
    enum state{
    	ready, execute, block, finish
    };//定义进程状态
    
    
    
    struct pcb{
    	char name[4];	//进程名
    	int priority;	//优先权
    	int cputime;	//CPU 运行时间
    	int needtime;	//进程运行所需时间
    	int count;	//进程执行次数
    	int round;	//时间片轮转轮次
    	state process;	//进程状态
    	pcb * next;
    };	//定义进程 PCB
    
    
    
    pcb * get_process(){
        pcb *q;
        pcb *t;//指向当前就绪进程
        pcb *p;//一个指针指向5个进程排成的就绪队列的第一个进程
        int i=0;
        cout<<"input name and time"<<endl;
        while (i<P_NUM)
        {
            q = (struct pcb *)malloc(sizeof(pcb));
    
            cin>>q->name;//进程名称
            cin>>q->needtime;//进程运行所需时间
            q->cputime=0;//初始cpu运行时间为0
            q->priority=P_TIME-q->needtime;//初始优先级: 50-所需 CPU 时间片数
            q->process=ready;//设置进程状态为就绪状态
            q->next=NULL;
    
            if (i==0){
                p=q;
                t=q;
            }
            else{
                t->next=q;	//创建就绪进程队列
                t=q;
            }
                i++;
        }	//while
            return p;
    }	//输入模拟测试的进程名和执行所需时间,初始设置可模拟 5 个进程的调度
    
    void	display(pcb *p){
        cout<<"name"<<"	"<<"cputime"<<" "<<"needtime"<<" "<<"priority"<<" "<<"state"<<endl;
        while(p){
            cout<<p->name;
            cout<<"	";
            cout<<p->cputime;
            cout<<"	";
            cout<<p->needtime;
            cout<<"	";
            cout<<p->priority;
            cout<<"	";
    
        switch(p->process){
            case ready:cout<<"ready"<<endl;break;
            case execute:cout<<"execute"<<endl;break;
            case block:cout<<"block"<<endl;break;
            case finish:cout<<"finish"<<endl;break;
        }
            p=p->next;
            }
    }	//显示模拟结果,包含进程名、CPU 时间、运行所需时间以及优先级
    
    int process_finish(pcb *q){
    	int bl=1;
    	//循环判断,从第一个开始,一旦找到一个所需时间不为0的,停止循环,返回。
    	while(bl&&q)
        {
            bl = bl && q->needtime == 0;
            q=q->next;
    	}
    	return bl;
    }	//结束进程,即将队列中各进程的所需时间设置为 0
    
    
    
    void cpuexe(pcb *q){
    	pcb *t=q;
    	int tp=0;
    	while(q)
        {
    		if (q->process != finish)
            {
    			q->process=ready;
    			if(q->needtime==0){
    				q->process=finish;
    			}
    		}
    
    		//循环选择优先级最高的进程
    		if(tp < q->priority && q->process != finish){
    			tp = q->priority;//第一次循环获取第一个进程的优先级数
    			t = q;
    		}
    
    		q=q->next;
        }
        if(t->needtime!=0){
            t->priority-=3;//进程每执行一次,优先数减 3
            t->needtime--;//进程还需要的时间片数减 1
            t->process=execute;//状态变为执行
            t->cputime++;//CPU 时间片 数加 1
            }
    }	//选择某一进程,给它分配 CPU
    //计算进程优先级
    
    void priority_cal(){
    	pcb * p;
    	system("cls");
    	//clrscr();
    	p=get_process();//获取就绪进程队列首地址
    	int cpu=0;
    	system("cls");
    	//clrscr();
    	while(!process_finish(p)){
    		cpu++;
    		cout<<"cputime:"<<cpu<<endl;
    		cpuexe(p);
    		display(p);
    		Sleep(2);
    		//system("cls");
    		//clrscr();
    	}
    	printf("All processes have finished,press any key to exit");
    	getch();
    }
    
    void display_menu(){
    	cout<<"CHOOSE THE ALGORITHM:"<<endl;
    	cout<<"1 PRIORITY"<<endl;
    	cout<<"2 ROUNDROBIN"<<endl;
    	cout<<"8 EXIT"<<endl;
    }	//显示调s度算法菜单,可供用户选择优先权调度算法和时间片轮转调度算法
    
    
    int main(){
    	display_menu();//显示菜单
    	int k;
    	scanf("%d",&k);
    	while(k!=8)
        {
            switch(k)
            {
                case 1:priority_cal();break;
                case 2:round_cal();break;
            }
            if(k==1||k==2)
                break;
            else
            {
                system("cls");
                display_menu();
                scanf("%d",&k);
            }
        }
    }

    代码分析:

    程序执行流程如下:

     

    展开全文
  • 在时间片轮转调度算法中,做了一个隐含的假设

    在时间片轮转调度算法中,做了一个隐含的假设,即系统中所有进程的紧迫性是相同的。但实际情况并非如此,为了能满足实际情况的需要,在进程调度算法中引入优先级,而形成优先级调度算法。


    本例中实现的优先级的定义为:

     优先数 = 50 - 运行时间

     每运行一次优先数减3,重新竞争。


    实现效果:(只列出输入和最终输出,省略中间过程)





    Java实现过程

    PCB类在比起时间片轮转算法中新增一个priorityNumber(省略了各个变量的gettersetter

    public class PCB {
    	
    	String name;
    	int priorityNumber=50;
    	int cpuTime=0;
    	int needTime;
    	char state='W';
    	
    	public PCB(String name,int needTime){
    		this.name = name;
    		this.needTime = needTime;
    		this.priorityNumber = 50-needTime;
    	}
    	
    	public void printInformation(){
    		System.out.println(this.getName() +"\t" + this.getCpuTime() + "\t" + this.getNeedTime() + "\t\t" + this.getState());
    	}
    	......
    }
    

    循环一下处理过程并输出

    // 找出优先级最高的进程
    			int maxPriorityNumber = 0;
    			for (PCB tempPCB : currentQueue) {
    				if(tempPCB.getPriorityNumber()>maxPriorityNumber){
    					maxPriorityNumber=tempPCB.getPriorityNumber();
    				}
    			}
    			// 把优先级最高的进程调配到队首
    			while(currentQueue.peek().getPriorityNumber() < maxPriorityNumber){
    				currentQueue.offer(currentQueue.peek());
    				currentQueue.poll();
    			}
    进程调度处理

    PCB processingPCB = currentQueue.poll();
    			if (processingPCB.state != 'F') {
    				waitQueue.poll();
    				processingPCB.setState('R');
    				if (processingPCB.getNeedTime() > round) {
    					processingPCB
    							.setCpuTime(processingPCB.getCpuTime() + round);
    					processingPCB.setNeedTime(processingPCB.getNeedTime()
    							- round);
    					processingPCB.setState('W');
    				} else {
    					processingPCB.setCpuTime(processingPCB.getCpuTime()
    							+ processingPCB.getNeedTime());
    					processingPCB.setNeedTime(0);
    					processingPCB.setState('F');
    				}
    				// 执行完毕竞争数减3
    
    			}
    			currentQueue.offer(processingPCB);
    遍历输出结果(略)







    展开全文
  • 采用的是短作业优先调度算法、时间片轮转调度、最高优先级优先算法三种算法中的最高优先级算法。 题目阐述如下:  设计一:进程调度 设计目的: 进程管理是操作系统中的重要功能,用来创建进程、撤消进程、...

    原创


    最近几周操作系统实习,要求完成几道题目,下面是自己敲出来的模拟在单处理器情况下的进程调度算法(说算法可能过于高大尚),

    采用的是短作业优先调度算法、时间片轮转调度、最高优先级优先算法三种算法中的最高优先级算法。

    题目阐述如下:

                        设计一:进程调度

      设计目的:    

      进程管理是操作系统中的重要功能,用来创建进程、撤消进程、实现进程状态转换,它提供了在可运行的进程之间复用CPU的方法。

    在进程管理中,进程调度是核心,因为在采用多道程序设计的系统中,往往有若干个进程同时处于就绪状态,当就绪进程个数大于处

    理器数目时,就必须依照某种策略决定哪些进程优先占用处理器。本设计模拟在单处理器情况下的进程调度,目的是加深对进程调度

    工作的理解,掌握不同调度算法的优缺点。

      设计内容:

    设计程序模拟单处理机系统中的进程调度算法,在短作业优先调度算法、时间片轮转调度、最高优先级优先算法三种算法中选择两种实现。

    每个进程由一个进程控制块(PCB)表示。进程控制块可以包含如下信息:进程名、优先数、到达时间、需要运行时间、已用CPU时间、进

    程状态等。进程的优先数及需要的运行时间可以事先人为地指定(也可以由随机数产生)。进程的到达时间为进程输入的时间。

    进程的运行时间以时间片为单位进行计算。

    每个进程的状态可以是就绪W(Wait)、运行R(Run)或完成F(Finish)3中状态之一。

    以下是最高优先级优先算法思想:

    就绪进程获得CPU后都只能运行一个时间片,用已占用CPU时间加1来表示。

    如果运行一个时间片后,进程的已占用CPU时间已达到所需要的运行时间,则撤销该进程,如果运行一个时间片后进程的已占用CPU时间

    还未达到所需要的运行时间,也即进程还需要继续运行,此时应将进程的优先数减1(即降低一级),然后把它插入就绪队列等待CPU。

    每进行一次调度程序都打印一次运行进程、就绪队列以及各个进程的PCB,以便进行检查。

    重复以上过程,直到所有进程都完成为止。

     

    每个PCB进程包括:进程名、优先数、到达时间、需要运行时间、已用CPU时间、进程状态;采用结构体类型来存储一个PCB。

    采用的数据结构是队列,创建的进程形成一个双向队列(采用双向队列容易寻找前驱结点的地址),遍历队列,从中找出优先级

    最高的PCB取出(相当于调入CPU),将其优先数降低,增加其已用CPU时间,改变其进程状态;然后判断其已用CPU时间是否

    大于等于需要运行时间,大于将其进程状态置为完成状态,否则将此PCB插入队列尾部,再次在队列中寻找优先级最高的PCB......

    /*
        最高优先级算法 
    */
    #include<stdio.h>
    #include<stdlib.h>
    #include<time.h>
    #define N 3
    #define Time_film 2    //时间片
    
    int count = 0;    //统计进程完成个数 
    
    void print(struct PCB *head);
    
    struct PCB{
        int process_name;    //进程名 
        int priority_number;    //优先数,随机产生 
        int arrive_time;    //到达时间,为进程的创建时间 
        int need_time;    //需要运行的时间,随机产生 
        int used_time;    //已用CPU的时间,初始值为0 
        int process_state;    //进程状态,1表示运行,0表示完成,-1表示就绪,初始值为-1 
        struct PCB *cre;    //前驱指针域
        struct PCB *next;    //后驱指针域
    };
    
    void Process_scheduling(struct PCB *head){
        /*
        扫描队列,寻找最高优先数的PCB,调入CPU运行;
        如果 use_CPU == need_time 撤销此PCB;
        否则用完一个时间片后放回队列尾部,继续扫描;
        */
        //****************************
        struct PCB *Move=head->next;
        struct PCB *Max_Pri=head->next;
        struct PCB *Tail;    //尾指针 
        //****************************
        while(Move!=NULL){
            if(Max_Pri->priority_number < Move->priority_number){
                Max_Pri = Move;
            }                        //寻找最高优先级进程 
            Move = Move->next;
        }
        //****************************
        Move = Max_Pri->cre;        //将最高优先级进程调出
        Move->next = Max_Pri->next;
        if(Move->next != NULL){
            Move = Max_Pri->next;
            Move->cre = Max_Pri->cre;    
        }
        //****************************
        printf("        进程 %d 被调度: \n",Max_Pri->process_name);
        Max_Pri->used_time += Time_film;    //增加CPU占用时间
        if(Max_Pri->used_time >= Max_Pri->need_time){
            Max_Pri->used_time = Max_Pri->need_time;    //进程状态改变
            Max_Pri->process_state = 0;
            count++;
        }
        else{
            Max_Pri->process_state = 1;
        }
        Max_Pri->priority_number-=1;    //优先数减1
        printf(" %d     %d     %d        %d         %d      %d \n\n",Max_Pri->process_name,Max_Pri->priority_number,Max_Pri->arrive_time,Max_Pri->need_time,Max_Pri->used_time,Max_Pri->process_state);
        if(count == N){    //所有进程执行完毕 
            printf("        所有进程执行完毕!");
            return;
        }
        printf("        就绪队列:\n");
        print(head);    //输出就绪队列
        printf("\n");
        //****************************
        if(Max_Pri->process_state !=0){
            Move = head;
            while( Move->next!=NULL ){    //当被调出进程未完成时将其插入就绪队列尾部 
                Move = Move->next; 
            }
            Tail = Move;
            Max_Pri->cre = Tail;
            Max_Pri->next = NULL;
            Tail->next = Max_Pri;
            Max_Pri->process_state = -1;
        }
        //****************************
        Process_scheduling(head);
    }
    
    void print(struct PCB *head){    //输出队列函数 
        if(head->next == NULL){
            printf("就绪队列已空\n");
            return;
        }
        printf("name priority arr_time need_time use_CPU pro_state\n");
        struct PCB *fry = head->next;
        while(fry != NULL){
            printf(" %d     ",fry->process_name);
            printf("%d     ",fry->priority_number);
            printf("%d        ",fry->arrive_time);
            printf("%d         ",fry->need_time);
            printf("%d      ",fry->used_time);
            printf("%d ",fry->process_state);
            printf("\n");
            fry = fry->next;    
        }
        printf("\n"); 
    }
    
    int main(){
        struct PCB *head;    //头指针
        struct PCB Pro[N+1];    //创建 N+1 个进程
        head = &Pro[0];
        srand(time(0));
        
        //****************************
        //设置进程参数
        Pro[0].process_name = 0;
        Pro[0].cre = NULL;
        Pro[0].next = &Pro[1];
        Pro[0].priority_number = 0;
        int i=0;
        for(i=1;i<=N;i++){
            Pro[i].process_name = i;
            Pro[i].priority_number = rand()%10;
            while(Pro[i].priority_number == 0){
                Pro[i].priority_number = rand()%10;
            }
            Pro[i].arrive_time = i;
            Pro[i].need_time = rand()%7;
            while(Pro[i].need_time == 0){
                Pro[i].need_time = rand()%7;
            }
            Pro[i].used_time = 0;
            Pro[i].process_state = -1;
        }
        for(i=1;i<=N;i++){    //形成双向队列
            if( i == N ){
                Pro[i].cre = &Pro[i-1];
                Pro[i].next = NULL;
                break;
            }
            Pro[i].cre = &Pro[i-1];
            Pro[i].next = &Pro[i+1];
        }
        //****************************
        
        printf("        进程初始状态: \n");
        print(head);    //输出初始队列状态
        
        Process_scheduling(head);    //调用进程调度函数(最高优先级)
        
        return 0;
    }

    (运行结果部分截图)

    10:58:00 

    2018-05-12

     

    改进:

    上面忽视了进程的到达时间这个因素,会产生致命错误:

    进程没有到达,但是其优先级最高,还是会被调用!

    必须从已经到达的进程中选择优先级最高的调入CPU运行,每个进程每次使用一次时间片后必须判断哪些进程已经到来,然后再

    所有到达的进程中选择优先级最高的调入CPU运行;可以设置一个动态的系统时间 system_time(初始值为最先到达进程的到

    达时间)system_time 在每个进程执行完一次后都增加该进程此次执行的时间(这里不指明每次执行时间为时间片是因为当进程

    剩下需要的执行时间小于一个时间片后 system_time 不会增加一个时间片),进程每次执行完一个时间片后,将 system_time

    每个进程的到达时间进行比较,大于 system_time 则未到达,反之,到达;再从已到达的进程中选择优先级最高的调入CPU运

    行......值得一提的是,若遇到进程到来比较晚( system_time<进程的到达时间)前面的进程都已经执行完成(已从队列中移除)

    则通过 system_time 将找不到合适的进程调入,此时必须通过 “手动”添加系统时间来达到下一个进程的到达时间,然后将其执行。

    /*
        最高优先级算法 
    */
    #include<stdio.h>
    #include<stdlib.h>
    #include<time.h>
    #define N 5
    #define Time_film 2    //时间片
    
    int count = 0;    //统计进程完成个数 
    int system_time=100; 
    int flag=0;
    int ff=0;
    
    void print(struct PCB *head);
    
    struct PCB{
        int process_name;    //进程名
        int priority_number;    //优先数,随机产生 
        int arrive_time;    //进程的到达时间,随机产生 
        int need_time;    //需要运行的时间,随机产生 
        int used_time;    //已用CPU的时间,初始值为0 
        int process_state;    //进程状态,1表示运行,0表示完成,-1表示就绪,初始值为-1 
        struct PCB *cre;    //前驱指针域
        struct PCB *next;    //后驱指针域
    };
    
    void Process_scheduling(struct PCB *head){
        /*
        扫描队列,将最先到达的进程调入运行,若多个进程
        同时到达,选取优先级最高的进程    调入,运行状态
        的进程用完一个时间片后判断是否进程是否执行完毕
        或有新进程到达,加入新进程后再次选取优先级最高
        的调入运行,直至进程全部调用完毕。 
        */
         
        //****************************
        struct PCB *Move=head->next;
        struct PCB *Max_Pri=head;
        struct PCB *Tail;    //尾指针 
        //****************************
        
        /*
        while(Move!=NULL){
            if(Max_Pri->arrive_time > Move->arrive_time){    //寻找最早到达的进程 
                Max_Pri = Move;
            }
            Move = Move->next;
        }
        Move=hear->next;
        while(Move!=NULL){    //在几个同时最早时间到达的进程中选择优先级最高的 
            if(Max_Pri->arrive_time == Move->arrive_time){
                if(Max_Pri->priority_number>Move->priority_number){
                    Max_Pri=Move;
                }
            }
            Move=Move->next; 
        }
        */
        flag=0;
        ff=0;
        while(++flag){
            Move=head->next;
            Max_Pri=head;
            while(Move!=NULL){
                if(Move->arrive_time <= system_time){    //小于等于系统时间的进程说明已经到达,小于系统时间的进程都要相互比较优先级
                    if(Move->priority_number>Max_Pri->priority_number){
                        Max_Pri=Move;
                    }    
                }
                Move=Move->next;
            }
            if(Max_Pri->cre==NULL){    //说明没有选出合适进程,需要增加系统时间
                ff=1;
                system_time++; 
            }
            else{
                break;
            }
        }
        if(ff==1){
            printf("暂无进程可执行,等待 %d 后,系统时间为: %d \n\n",flag-1,system_time);
        }
        //****************************
        Move = Max_Pri->cre;        //将上面选择的进程调入CPU运行
        Move->next = Max_Pri->next;
        if(Move->next != NULL){
            Move = Max_Pri->next;
            Move->cre = Max_Pri->cre;
        }
        //****************************
        printf("        进程 %d 被调度: \n",Max_Pri->process_name);
        Max_Pri->used_time += Time_film;    //增加CPU占用时间
        if(Max_Pri->used_time >= Max_Pri->need_time){
            if(Max_Pri->used_time==Max_Pri->need_time){
                system_time+=Time_film;
            }
            if(Max_Pri->used_time > Max_Pri->need_time){
                system_time+=(Max_Pri->used_time-Max_Pri->need_time);
            }
            Max_Pri->used_time = Max_Pri->need_time;
            Max_Pri->process_state = 0;        //进程状态改变
            count++;
        }
        else{
            system_time+=Time_film;
            Max_Pri->process_state = 1;
        }
        Max_Pri->priority_number-=1;    //优先数减1
        printf(" %d     %d     %d        %d         %d       %d\n\n",Max_Pri->process_name,Max_Pri->priority_number,Max_Pri->arrive_time,Max_Pri->need_time,Max_Pri->used_time,Max_Pri->process_state);
        if(count == N){    //所有进程执行完毕 
            printf("        所有进程执行完毕!");
            return;
        }
        if(Max_Pri->process_state==1){
            printf("进程 %d 未完成,进入就绪队列,系统时间为: %d \n\n",Max_Pri->process_name,system_time);
        }
        else{
            printf("进程 %d 已完成,系统时间为: %d \n\n",Max_Pri->process_name,system_time);
        }
        printf("        就绪队列:\n");
        //****************************
        if(Max_Pri->process_state !=0){
            Move = head;
            while( Move->next!=NULL ){    //当被调出进程未完成时将其插入就绪队列尾部
                Move = Move->next; 
            }
            Tail = Move;
            Max_Pri->cre = Tail;
            Max_Pri->next = NULL;
            Tail->next = Max_Pri;
            Max_Pri->process_state = -1;
        }
        print(head);
        //****************************
        Process_scheduling(head);
    }
    
    void print(struct PCB *head){    //输出队列函数 
        if(head->next == NULL){
            printf("就绪队列已空\n");
            return;
        }
        printf("name priority arr_time need_time use_CPU pro_state\n");
        struct PCB *fry = head->next;
        while(fry != NULL){
            printf(" %d     ",fry->process_name);
            printf("%d     ",fry->priority_number);
            printf("%d        ",fry->arrive_time);
            printf("%d         ",fry->need_time);
            printf("%d      ",fry->used_time);
            printf("%d          ",fry->process_state);
            printf("\n");
            fry = fry->next;
        }
        printf("\n"); 
    }
    
    int main(){
        struct PCB *head;    //头指针
        struct PCB Pro[N+1];    //创建 N+1 个进程-----就绪状态队列
        srand(time(0));
        
        //****************************
        //设置就绪状态进程参数
        head = &Pro[0];
        int i=0;
        for(i=0;i<=N;i++){
            if(i==0){
                Pro[i].process_name = 0;
                Pro[i].cre = NULL;
                Pro[i].next = &Pro[i+1];
                Pro[i].priority_number = -100;
                continue;
            }
            Pro[i].process_name = i;
            Pro[i].priority_number = rand()%10;
            while(Pro[i].priority_number == 0){
                Pro[i].priority_number = rand()%10;
            }
            Pro[i].arrive_time = rand()%10;
            Pro[i].need_time = rand()%7;
            while(Pro[i].need_time == 0){
                Pro[i].need_time = rand()%7;
            }
            Pro[i].used_time = 0;
            Pro[i].process_state = -1;
        }
        for(i=1;i<=N;i++){    //形成双向队列
            if( i == N ){
                Pro[i].cre = &Pro[i-1];
                Pro[i].next = NULL;
                break;
            }
            Pro[i].cre = &Pro[i-1];
            Pro[i].next = &Pro[i+1];
        }
        //****************************
        for(i=1;i<=N;i++){    //将最先到达进程的时间设置为系统开始时间 
            if(Pro[i].arrive_time<system_time){ 
                system_time=Pro[i].arrive_time;
            }
        }
        printf("系统时间为: %d \n",system_time);
        //****************************
        
        
        printf("        就绪状态进程: \n");
        print(head);    //输出就绪状态进程 
        
        Process_scheduling(head);    //调用进程调度函数(最高优先级)
        
        return 0;
    }

    (运行结果部分截图)

    16:31:29

    2018-05-18

    转载于:https://www.cnblogs.com/chiweiming/p/9028002.html

    展开全文
  • #include&lt;stdio.h&gt;struct PCB //表示每一个进程控制块 { char name[30]; //进程的名字 int number; //进程的编号  float run_time; //进程运行时间  float run_begin_time;... //进程优先级 flo...
  • 操作系统中进程调度是处理及管理的核心内容。 阅读本文,需要有一定的C/C++、数据结构基础。 内容介绍 采用C++编写程序,选用优先数调度算法或简单轮转法对五个进程进行调度,每个进程处于运行(Run)、就绪...
  • java实现进程调度(优先数调度算法) package 测试; public class Experiment2 { public static void main(String[] args) { int unfinished=5; //定义未完成的进程个数 int runcount=1; //定义是第几...
  • Java操作系统进程调度算法——优先级调度(HPF)算法 文章目录Java操作系统进程调度算法——优先级调度(HPF)算法前言一、算法思想二、数据结构1.定义(PCB)进程控制块2.实现思路三、流程图四、完整代码运行结果1、输入...
  • 模拟进程调度优先级算法和时间轮转算法。。无bug,可支持模拟100个进程同时测试。。,内有代码注释说明
  • 模拟进程调度中的高优先级优先调度算法
  • /*非抢占式优先级调度算法*/ #include <iostream> using namespace std; struct Num { int priority; //优先级 int dt; //到达时间 int st; //运行时间 }su...
  • 最近学习了操作系统内诸多进程调度算法,动手实现了抢占式优先级调度算法 知识点 该算法又称为优先权调度算法,他既可以用于作业调度,又可用于进程调度。该算法中的优先级用于描述作业运行的紧迫程度。 两种类型: ...
  • 操作系统实验 短作业优先进程算法 基于优先级进程调度算法 先来先服务进程算法
  • 题 目: 进程调度模拟设计——优先级法、最高响应比优先调度算法 初始条件: 1.预备内容:阅读操作系统的处理机管理章节内容,对进程调度的功能以及进程调度算法有深入的理解。 2.实践准备:掌握一种计算机高级...
  • 进程调度算法有很多,例如先来先服务调度算法(FCFS),短作业优先算法(SJF),时间片轮转算法(RR)和优先级算法,这里我将通过代码的方式主要介绍轮转调度算法(RR)和动态优先级调度算法.  首先介绍下轮转调度算法:
  • //进程调度 int dosth(int x); //占用cpu执行任务 //空闲队列 struct free{ int fhead; //空闲队列头 int ftail; //空闲队列尾 }free01; struct prepare{ int phead; //就绪队列头 int ptail; //就绪队列尾 }...
  • 调度算法-优先级调度算法+例题详解

    千次阅读 2021-04-20 20:31:09
    优先级进程调度算法,是把处理机分配给就绪队列中优先级最高的进程。这时,又可进一步把该算法分成如下两种。 非抢占式优先级调度算法。 抢占式优先级调度算法。 2. 优先级的类型 静态优先级 静态优先级是在创建...
  • 进程调度详解算法

    千次阅读 2020-04-08 09:40:26
    进程调度详解算法及C语言实现引言原因进程调度的指标进程调度的时机进程调度的方式进程调度的策略/算法算法详解先来先服务(FCFS)调度算法短作业优先(SJF)调度算法时间片轮转(RR)调度算法高响应比优先(HRRF)...
  • 进程调度:也叫低级调度,操作的也是进程;进程的调度还分为:非剥夺式调度:大家排队,别想插队。剥夺式调度:一些人可以插队,一些人继续排队。剥夺式调度里面,到底谁可以插队,谁不能插队?那也要按规矩来!这个...
  • 优先级调度算法3.多级反馈队列调度算法4.三种算法的对比总结 0.思维导图 1.时间片轮转—RR Round-Robin 时间片为2举例 以时间片为5举例 可能出现的问题,比如与FCFS对比 2.优先级调度算法 非抢占式例子 -...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 47,902
精华内容 19,160
关键字:

进程调度优先级算法