精华内容
下载资源
问答
  • 时间片轮转发加优先级进程调度算法如下: #include <stdio.h> struct PCB { int ID; int Alltime; int Cputime; int Priority; int starte; }; int maxpriorityxiabiao(PCB pcb[],int n) { int ...

    时间片轮转发加优先级的进程调度算法如下:

    #include <stdio.h>


    struct PCB
    {
        int ID;
        int Alltime;
        int Cputime;
        int Priority;
        int starte;
    };

    int maxpriorityxiabiao(PCB pcb[],int n)
    {
        int max = -10000;
        int a = 0;
        for(int i = 0; i < n; i++)
        {
                max = max > pcb[i].Priority?max : pcb[i].Priority;
                if(max == pcb[i].Priority)
                {
                    a = i;
                }
        }
        return a;
    }

    void sort(PCB pcb[],int n)
    {
        PCB p;
        for(int i = 0; i < n; i++)
        {
            for(int j = i + 1; j < n; j++)
            {
                if(pcb[i].Priority < pcb[j].Priority)
                {
                    p = pcb[i];
                    pcb[i] = pcb[j];
                    pcb[j] = p;
                }
            }
        }
    }

    void priority(PCB pcb[],int n)
    {
        int sum = 1;
        int *time = new int[n];
        float count = 0;
        while(sum!=0)
        {    
            sort(pcb,n);
            printf("当前就绪队列:");
            for(int i = 0; i < n; i++)
            {
                if(pcb[i].Alltime!=0)
                {
                    printf("%d",pcb[i].ID);
                }
            }
            int id = maxpriorityxiabiao(pcb,n);
            printf("\n");
            printf("当前执行的程序ID:%d        ",pcb[id].ID);
            pcb[id].Alltime--;
            pcb[id].Cputime++;
            pcb[id].Priority = pcb[id].Priority-3;
            count++;
            printf("执行后Alltime:%d\n",pcb[id].Alltime);
            printf("执行后Cputime:%d            ",pcb[id].Cputime);
            printf("执行后Priority:%d\n",pcb[id].Priority);
            printf("\n");
            printf("\n");
            if(pcb[id].Alltime == 0)
            {
                pcb[id].Priority = -10000;
                time[pcb[id].ID] = (int)count;
            }
            sum = 0;
            for(int j = 0; j < n; j++)
            {
                sum+=pcb[j].Alltime;
            }
        }
        count = 0;
        for(int i = 0; i < n; i++)
        {
            printf("ID:%d运行时间是:%d\n",i,time[i]);
            
            count += time[i];
        }
        printf("进程平均周转时间是:%f\n",count/n);
    }
    void main()
    {
        PCB pcb[5] = {{0,4,0,12,1},
                    {1,2,0,16,1},
                    {2,3,0,13,1},
                    {3,6,0,17,1},
                    {4,3,0,26,1}
                    };
        priority(pcb,5);
    }

     

    展开全文
  • 模拟进程调度中的高优先级优先调度算法
  • 发段源代码给你 有兴趣自己慢慢理解#include #include #include #include #include #include #include #include #define ESC 0x1b#define ENTER 0x0d#define TRUE 1#define FALSE 0/*每隔TIME秒就变换一次优先级*/#...

    展开全部

    没java的 发段源代码给你 有兴趣自己慢慢理解

    #include

    #include

    #include

    #include

    #include

    #include

    #include

    #include

    #define ESC 0x1b

    #define ENTER 0x0d

    #define TRUE 1

    #define FALSE 0

    /*每隔TIME秒就变换一次优先级*/

    #define TIME 5

    /*数据结构*/

    /****************************************************************/

    enum _Status/*进程状态枚举*/

    {

    READY =0,/*就绪32313133353236313431303231363533e4b893e5b19e31333236373239*/

    RUN,/*执行中*/

    SUSPEND,/*挂起*/

    };

    typedef enum _Status Status;

    /****************************************************************/

    struct _Pcb/*进程结构*/

    {

    int PID;/*进程ID,ID为负数的进程为系统后备队列的作业*/

    int Time;/*进程运行需要的时间*/

    int Prior;/*进程的优先级,越大越优先*/

    Status Sts;/*状态*/

    struct _Pcb *Next;/*指向本进程队列中下个进程的PCB*/

    };

    typedef struct _Pcb PCB;

    /****************************************************************/

    struct _Batch/*多道处理中的道结构*/

    {

    PCB *pcb;/*该道当前正在处理的进程*/

    struct _Batch *Next;/*下一道*/

    };

    typedef struct _Batch Batch;

    /****************************************************************/

    /*多道系统相关全局变量*/

    PCB *ProcQueue = NULL;/*进程链表,按优先级从大到小排列*/

    Batch *BatchQueue = NULL;/*系统多道链表*/

    /****************************************************************/

    /*动态优先权抢占式调度算法及相关函数声明*/

    /****************************************************************/

    int InitBatchs(int n);/*初始化多道系统,n为道数*/

    int InsertProc(int prior, int time);/*向进程链表中按优先级大小插入一个新进程*/

    int InsertIDLE();/*向进程队列中加入后备进程,当系统空闲时将被调入*/

    int SortProcQueue();/*将进程链表按优先级从大到小排列*/

    int AddBatch();/*增加系统道数*/

    int DeleteBatch();/*减少系统道数*/

    int UnSuspendProc(int id);/*解除ID为id的进程的挂起状态*/

    int UpdateBatchs();/*多道系统根据进程链表进行更新,并将执行完毕的进程删除*/

    int PassSeconds(int n);/*系统经过n秒后计算数据并进行优先级调度*/

    /****************************************************************/

    /*各函数的定义*/

    /****************************************************************/

    int InitBatchs(int n)

    {

    int i;

    for (i=0; i

    {

    AddBatch();

    }

    return (UpdateBatchs());

    }

    int InsertProc(int prior, int time)

    {

    static int sysid = 0;/*该系统已经加入过多少进程,此值将是新进程的ID*/

    PCB *last,*now,*pcb;

    pcb = (PCB*)malloc(sizeof(PCB));

    if (pcb == NULL) return FALSE;

    pcb->Prior = prior;

    pcb->Time = time;

    pcb->PID = (++sysid);

    pcb->Sts = READY;

    if (ProcQueue == NULL)/*如果进程队列为空*/

    {

    ProcQueue = pcb;

    pcb->Next = NULL;

    return TRUE;

    }

    last = ProcQueue;

    now = last->Next;

    if (pcb->Prior > last->Prior)/*pcb将排在队头*/

    {

    pcb->Next = ProcQueue;

    ProcQueue = pcb;

    return TRUE;

    }

    while ((now != NULL) && (pcb->Prior < now->Prior))/*寻找插入位置*/

    {

    last = now;

    now = last->Next;

    }

    last->Next = pcb;

    pcb->Next = now;

    return TRUE;

    }

    int InsertIDLE()

    {

    PCB *now = ProcQueue;

    PCB *idle = (PCB*)malloc(sizeof(PCB));

    if (idle == NULL) return FALSE;

    idle->PID = -1;

    idle->Prior = -1;

    idle->Sts = SUSPEND;

    idle->Time = -1;

    idle->Next = NULL;

    if (ProcQueue == NULL)

    {

    ProcQueue = idle;

    return TRUE;

    }

    while(now->Next != NULL)

    {

    now = now->Next;

    }

    now->Next = idle;

    return TRUE;

    }

    int SortProcQueue()

    { /*冒泡排序*/

    PCB *last, *now;

    int b = FALSE;/*上次遍历是否无交换产生*/

    if (ProcQueue==NULL || ProcQueue->Next==NULL)/*如果链表中无进程或只有一个进程*/

    return FALSE;

    while (!b)

    {

    b = TRUE;

    last=ProcQueue;

    now=last->Next;

    if (last->Prior < now->Prior)

    {

    ProcQueue = now;

    last->Next = now->Next;

    now->Next = last;

    b = FALSE;

    last = ProcQueue;

    now = last->Next;

    }

    while (now->Next!=NULL)

    {

    if ((now->Prior)Next->Prior))

    {

    last->Next = now->Next;

    now->Next = now->Next->Next;

    last->Next->Next = now;

    b = FALSE;

    }

    else

    last = last->Next;

    now = last->Next;

    }

    }

    return TRUE;

    }

    int AddBatch()

    {

    Batch *bt = (Batch*)malloc(sizeof(Batch));

    if (bt==NULL) return FALSE;

    bt->Next = BatchQueue;

    BatchQueue = bt;

    bt->pcb = NULL;

    return (InsertIDLE());

    }

    int DeleteBatch()

    {

    Batch *bt = BatchQueue;

    PCB *last, *now;

    if (BatchQueue==NULL || BatchQueue->Next==NULL)/*如果只剩最后一道则不删除*/

    return FALSE;

    if (ProcQueue==NULL || ProcQueue->Next==NULL)/*如果只有最后一个后备空闲进程*/

    return FALSE;/**/

    last = ProcQueue;

    now = last->Next;

    while (now->Next != NULL)/*查找到最后一个进程,该进程必定是后备空闲进程*/

    {

    last = now;

    now = last->Next;

    }

    if (now==NULL || now->PID>=0)/*未查找到后备进程*/

    return FALSE;/**/

    free(now);

    last->Next = NULL;

    BatchQueue = BatchQueue->Next;

    free(bt);

    return TRUE;

    }

    int UnSuspendProc(int id)

    {

    PCB *now = ProcQueue;

    if (ProcQueue==NULL) return FALSE;

    while (now != NULL)

    {

    if (now->PID == id)

    {

    now->Sts = READY;

    return TRUE;

    }

    }

    return FALSE;

    }

    int UpdateBatchs()

    {

    Batch *bt = BatchQueue;

    PCB *last = ProcQueue, *now;

    while (bt != NULL)

    {

    bt->pcb = NULL;

    bt = bt->Next;

    }

    if (ProcQueue == NULL) return TRUE;

    while (last->Sts==RUN && last->PID>=0 && last->Time<=0)

    {

    ProcQueue = ProcQueue->Next;

    free(last);

    last = ProcQueue;

    }

    now = last->Next;

    while (now != NULL)

    {

    if (now->Sts==RUN && now->PID>=0 && now->Time<=0)/*如果该进程是运行中的一般进程并已执行完毕*/

    {

    last->Next = now->Next;

    free(now);

    }

    else

    last = last->Next;

    now = last->Next;

    }

    bt = BatchQueue;

    now = ProcQueue;

    while (bt != NULL && now != NULL)

    {

    bt->pcb = now;

    now->Sts = RUN;

    bt = bt->Next;

    now = now->Next;

    }

    while (now != NULL)

    {

    if (now->Sts == RUN)

    {

    now->Sts = SUSPEND;

    }

    now = now->Next;

    }

    return TRUE;

    }

    int PassSeconds(int n)

    {

    static int time = 0;

    int i=0, ProcEnd = FALSE;

    PCB *pcb = ProcQueue;

    Batch *bt = BatchQueue;

    if (bt == NULL) return FALSE;

    time += n;

    if (time>=TIME)

    {

    i = time/TIME;/*经过多少时间段*/

    time = time%TIME;

    }

    while (bt != NULL)/*更新进程运行时间*/

    {

    if (bt->pcb->PID>=0)

    {

    bt->pcb->Time -= n;

    if (bt->pcb->Time <= 0)/*进程结束*/

    {

    ProcEnd = TRUE;

    }

    }

    bt = bt->Next;

    }

    if (i > 0)

    {

    while (pcb != NULL)/*更新进程优先权(动态优先权)*/

    {

    if (pcb->Sts == RUN && pcb->PID>=0)/*运行的进程优先权降低*/

    {

    pcb->Prior -= i;

    if (pcb->Prior < 0)

    pcb->Prior = 0;

    }

    else if (pcb->Sts == SUSPEND && pcb->PID>=0)/*挂起的进程优先权升高*/

    pcb->Prior += i;

    pcb = pcb->Next;

    }

    }

    if (i>0)

    SortProcQueue();/*如果优先级有变动则重新排序*/

    if (ProcEnd || i>0)

    {

    UpdateBatchs();/*更新多道进程*/

    }

    return TRUE;

    }

    /****************************************************************/

    /*图形界面相关函数*/

    /****************************************************************/

    /*表格的单位宽度和高度*/

    #define WIDTH 64

    #define HEIGHT 12

    void *black=NULL;/*背景色方格,使用它擦出表格中的图形*/

    int InitGraph()/*初始化图形界面*/

    {

    int GraphDriver; /* The Graphics device driver */

    int GraphMode; /* The Graphics mode value */

    int ErrorCode;

    GraphDriver = DETECT; /* Request auto-detection */

    initgraph( &GraphDriver, &GraphMode, "" );

    ErrorCode = graphresult(); /* Read result of initialization*/

    if( ErrorCode != grOk )

    { /* Error occured during init */

    printf(" Graphics System Error: %s\n", grapherrormsg( ErrorCode ) );

    getch();

    return FALSE;

    }

    cleardevice();

    black = (void*)malloc(imagesize(1,1,WIDTH-1,HEIGHT-1));

    getimage(1,1,WIDTH-1,HEIGHT-1,black);

    DrawFrame();

    DrawData();

    return TRUE;

    }

    int DrawFrame()/*画边框和表头*/

    {

    settextjustify(CENTER_TEXT, CENTER_TEXT);

    gprintf(320, HEIGHT/2-1, "Multi-Batch System Emulation");

    settextjustify(LEFT_TEXT, TOP_TEXT);

    moveto(0,HEIGHT);

    lineto(0,479);

    lineto(639,479);

    lineto(639,HEIGHT);

    lineto(0,HEIGHT);

    line(WIDTH*4,HEIGHT,WIDTH*4,479);

    line(WIDTH*7,HEIGHT,WIDTH*7,479);

    line(0,HEIGHT*2,639,HEIGHT*2);

    line(0,HEIGHT*3,639,HEIGHT*3);

    gprintf(HEIGHT*0+2,HEIGHT*1+2,"System Batchs");/*系统多道列表头*/

    gprintf(HEIGHT*0+2,HEIGHT*2+2,"Batch");

    gprintf(WIDTH*1+2,HEIGHT*2+2,"ProcID");

    gprintf(WIDTH*2+2,HEIGHT*2+2,"Time");

    gprintf(WIDTH*3+2,HEIGHT*2+2,"Prior");

    gprintf(WIDTH*4+2,HEIGHT*1+2,"Suspended Processes");/*挂起队列列表头*/

    gprintf(WIDTH*4+2,HEIGHT*2+2,"ProcID");

    gprintf(WIDTH*5+2,HEIGHT*2+2,"Time");

    gprintf(WIDTH*6+2,HEIGHT*2+2,"Prior");

    gprintf(WIDTH*7+2,HEIGHT*1+2,"Ready Processes");/*就绪队列列表头*/

    gprintf(WIDTH*7+2,HEIGHT*2+2,"ProcID");

    gprintf(WIDTH*8+2,HEIGHT*2+2,"Time");

    gprintf(WIDTH*9+2,HEIGHT*2+2,"Prior");

    }

    int DrawData()/*绘制系统数据*/

    {

    int numRun=0, numSus=0, numRed=0;/*运行挂起和就绪的进程各有多少*/

    PCB* now = ProcQueue;

    int x=0, y=0;

    while (now != NULL)

    {

    switch(now->Sts)

    {

    case RUN:

    x = WIDTH*1;

    y = HEIGHT*(3+(numRun++));

    break;

    case SUSPEND:

    x = WIDTH*4;

    y = HEIGHT*(3+(numSus++));

    break;

    case READY:

    x = WIDTH*7;

    y = HEIGHT*(3+(numRed++));

    break;

    }

    if (now->Sts==RUN)/*该进程为正在运行的进程*/

    {

    putimage(x-WIDTH+1,y+1,black,COPY_PUT);

    gprintf(x-WIDTH+2,y+2,"%d",numRun);

    }

    if (now->PID>=0)/*该进程不是后备进程*/

    {

    putimage(x+1,y+1,black,COPY_PUT);

    gprintf(x+2,y+2,"%d",now->PID);

    putimage(x+1+WIDTH,y+1,black,COPY_PUT);

    gprintf(x+WIDTH+2,y+2,"%d",now->Time);

    putimage(x+1+WIDTH*2,y+1,black,COPY_PUT);

    gprintf(x+WIDTH*2+2,y+2,"%d",now->Prior);

    }

    else

    {

    putimage(x+1,y+1,black,COPY_PUT);

    putimage(x+1+WIDTH,y+1,black,COPY_PUT);

    putimage(x+1+WIDTH*2,y+1,black,COPY_PUT);

    gprintf(x+2,y+2,"system idle process");

    }

    now = now->Next;

    }

    }

    int DlgGetNum(char *buf,int l,int t,int r,int b,int gettime)

    {

    char ch;

    int pos=0;

    bar(l,t,r,b);

    gprintf(l+10,t+5,"Add new Process");

    if (gettime)

    gprintf(l+10,t+20,"input the time:");

    else

    gprintf(l+10,t+20,"input the priority:");

    while (1)

    {

    ch = getch();

    if (ch == ENTER)/*如果输入了回车键*/

    {

    if(pos!=0)/*如果位置不在第一位(回车键不准第一个输入)*/

    {

    buf[pos]='\0';

    break;

    }

    }

    else if (ch>='0' && ch<='9')

    {

    buf[pos++]=ch;

    buf[pos]='\0';

    }

    else if (ch == ESC)

    {

    return FALSE;

    }

    else/*其他按键均按BackSpace处理*/

    {

    --pos;

    buf[pos]='\0';

    }

    if (pos<0)

    { pos=0; buf[pos]='\0';}

    else if (pos>4)/*最多输入4位数*/

    { pos=4; buf[pos]='\0';}

    bar(l,t+35,r,t+47);

    gprintf(l+50,t+35,buf);

    }

    return TRUE;

    }

    int NewProcDlg()

    {

    int l=200,t=150,r=380,b=200,pos=0,prior=0,time=0;

    char buf[5],ch;

    PCB *pcb;

    void* bg = (void*)malloc(imagesize(l,t,r,b));

    getimage(l,t,r,b,bg);

    setfillstyle(1,2);

    flushall();

    /*******输入优先级**********/

    if (!DlgGetNum(buf,l,t,r,b,FALSE))

    goto exit;

    prior = atoi(buf);

    /*******输入时间**********/

    pos=0;

    buf[pos]='\0';

    if (!DlgGetNum(buf,l,t,r,b,TRUE))

    goto exit;

    time = atoi(buf);

    InsertProc(prior, time);

    exit:

    putimage(l,t,bg,COPY_PUT);

    free(bg);

    return TRUE;

    }

    int gprintf( int xloc, int yloc, char *fmt, ... )/*图形系统中的格式输出*/

    {

    va_list argptr; /* Argument list pointer */

    char str[140]; /* Buffer to build sting into */

    int cnt; /* Result of SPRINTF for return */

    va_start( argptr, format ); /* Initialize va_ functions */

    cnt = vsprintf( str, fmt, argptr ); /* prints string to buffer */

    outtextxy( xloc, yloc, str ); /* Send string in graphics mode */

    va_end( argptr ); /* Close va_ functions */

    return( cnt ); /* Return the conversion count */

    }

    /****************************************************************/

    /*main函数*/

    int main()

    {

    clock_t start=0, end=0;

    char kb;

    InitBatchs(3);/*初始化为3道系统*/

    InitGraph();

    while (1)

    {

    start = end = clock();

    while (!kbhit())

    {

    start = clock();

    if ((start-end)/18.2 >= 1)/*时间过了一秒*/

    {

    start = end = clock();

    PassSeconds(1);

    cleardevice();

    DrawFrame();

    DrawData();

    }

    }

    kb = getch();

    switch (kb)

    {

    case ESC:

    closegraph();

    return 0;

    case 'w':

    AddBatch();

    UpdateBatchs();

    cleardevice();

    DrawFrame();

    DrawData();

    break;

    case 's':

    DeleteBatch();

    UpdateBatchs();

    cleardevice();

    DrawFrame();

    DrawData();

    break;

    case 'i':

    NewProcDlg();

    UpdateBatchs();

    DrawFrame();

    DrawData();

    break;

    }

    }

    return 0;

    }

    本回答由提问者推荐

    2Q==

    已赞过

    已踩过<

    你对这个回答的评价是?

    评论

    收起

    展开全文
  • 进程优先级调度算法

    2018-06-22 18:49:01
    《计算机与操作系统(第四版)》进程优先级调度算法 1.时间片轮转调度算法 2.多级反馈队列调度算法 3.高响应比优先调度算法
  • /*非抢占式优先级调度算法*/ #include <iostream> using namespace std; struct Num { int priority; //优先级 int dt; //到达时间 int st; //运行时间 }su...
    /*非抢占式优先级调度算法*/
    #include <iostream>
    using namespace std;
    struct Num
    {
    	int priority;		//优先级
    	int dt;				//到达时间
    	int st;				//运行时间
    }sum[5]={{2,0,3},{3,2,2},{5,2,5},{1,5,3},{4,8,1}};
    
    int main()
    {
    	int c=0;			//记录程序的执行个数
    	int time=0;			//记录时间
    	int b=100;		//记录上一个的程序
    	int a=100;
    	while(c<5)
    	{
    		//int t_t;		//找早到的优先级高的
    		int p=100;	//记录优先级
    
    		for(int i=0;i<5;i++)
    		{
    			if(time>=sum[i].dt)			//判断当前可执行的程序
    			{
    				if(p>sum[i].priority)	//判断最少运行时间
    				{
    					p=sum[i].priority;//更换优先级
    					a=i;				//录当前可运行的优先级的值
    				}
    			}
    		}
    		if(a!=b)					//判断当前的时间是否有程序可以运行
    		{								//有
    			time+=sum[a].st;
    			b=a;
    			cout<<"执行程序"<<b+1<<";等待时间:"<<time-sum[b].dt-sum[b].st<<";完成时间:"<<time<<"。"<<endl;
    		//	cout<<"**************"<<kkk<<"*****************"<<time<<endl;
    			sum[a].priority=100;
    			c++;
    		}
    		else
    		{								//找不到时间+1
    			time++;
    		}
    
    	}
    	return 0;
    }	

     

    转载于:https://my.oschina.net/u/3761238/blog/2440587

    展开全文
  • 采用动态优先数。即进程的优先数在创建进程时可以给定一个初始值,并且可以按一定原则修改优先数:在进程获得一次CPU后就将其优先数...“最高优先数优先”调度算法的基本思想是把CPU分配给就绪队列中优先数最高的进程
  • 操作系统进程调度中,优先级调度算法模拟,模拟进程调度,采用优先级调度算法,非抢占式,资源分配,资源分配。
  • 进程调进程调度算法进程调度算法进程调度算法进程调度调度算法进程调度算法进程调度算法
  • 优先级调度算法 优先级调度算法的类型 系统对于进程进行优先级上的划分,以此来对进程进行调度。当最高游戏机的进程运行完之后,系统自动调用后被队列中的优先级最高的进程来进行调用。 时间计算 对...

    调度算法思想

    短作业(进程)优先调度算法

    系统对于短进程或者作业进行调度,当有若干进程进入系统后,系统从队列中选择一个个或者是若干个来进行作业调度进程调度,当前进程运行完后接着寻找下一个最短时间的进程进行调度。

    优先级调度算法

    优先级调度算法的类型
    系统对于进程进行优先级上的划分,以此来对进程进行调度。当最高游戏机的进程运行完之后,系统自动调用后被队列中的优先级最高的进程来进行调用。

    时间计算

    对于调度算法中进程的执行顺序,来进行周转时间和带权周转时间上的计算:
    结束时间=开始时间+服务/执行时间
    周转周期=结束时间-到达时间
    带权周转时间=周转时间/服务时间

    优先级和短进程之间调用的区别

    优先级

    对于第一个进程的筛选,优先级通过输入的优先级别进行选择,即除了第一个到达系统的进程可以首先运行,在第一个进程运行中到达系统的进程都需要进行优先级的排序来运行,且不可抢占
    首先对于系统中的进程从开头设置while循环来进行筛选

    while ((j<counter)&&(process[i].come_time_hour==process[j].come_time_hour)&&(process[i].come_time_min==process[j].come_time_min))
    

    然后根据优先级别的高低来进行进程的首位筛选有无同一时刻到达的进程调用

        if (process[j].priority>process[i].priority)
         {
          max_priority=process[j].priority;
          i=j;
         }
        j++;
    

    通过进程的运行时间和到达时间来算出第一个进程结束的时间后,再进行下一个进程的筛选(这里用的是分号的运算方式,后面会提到分号和小数点的运算方式的区别)此时之前调用的进程中被标记为以调用,并且表示调用进程代码向下自增

    process[number_schedul].flag=1;//改程序已经运行一次所以运行标记修改为1 
    temp_time_hour=process[number_schedul].end_time_hour;//改时间作为结束时间  参与当下一程序进入后 检测下一程序  是否在上一个程序运行结束前进入 
    temp_time_min=process[number_schedul].end_time_min;
    process[number_schedul].order=1;//该进程的运行序列被排为第1个 
    temp_counter=1;//继续往该(最高优先级)进程下面检索下一个次于它的优先级进程 
    while (temp_counter<counter)
    {
       max_priority=0;
       for(j=0;j<counter;j++) 
       {
         if((process[j].come_time_hour<temp_time_hour)&&(!process[j].flag))//当该进程再上一个进程结束之前开始且该进程没被调用过 
         {
            if (process[j].priority>max_priority) //检测该进程的优先级要大于当前进程优先级 
            { 
              max_priority=process[j].priority;//进程替换,优先级改变 
              number_schedul=j;
            }
         }
        else if((process[j].come_time_hour=temp_time_hour)&&(process[j].come_time_min<=temp_time_min)&&(!process[j].flag))
        {
            if (process[j].priority>max_priority) //检测该进程的优先级要大于当前进程优先级 
            { 
              max_priority=process[j].priority;//进程替换,优先级改变 
              number_schedul=j;
            }
    	}
       }  
    

    在这里表示一点
    number_schedul为正在执行的进程编号,
    temp_counter已经调度完成的进程个数。
    之后继续进行下个进程的开始时间以及运行时间的叠加以此类推,直到所有进程都被调用完。

    最短进程

    在筛选第一个进程的时候,最短进程考虑的是如何查询出运行时间最短的进程,首先先筛选出同一时刻到达的进程并且进行运行时间上的对比

    while ((j<counter)&&(process[i].come_time_hour==process[j].come_time_hour)&&(process[i].come_time_min==process[j].come_time_min))
       {
        if (process[j].run_time<process[i].run_time) 
         { 
          run_time=process[j].run_time;
          i=j;
         }
        j++;
       }  
    

    当筛选出第一个进进程之后,进行算法上的运行(在下面会说到)运行完后系统则要判断并筛选出在第一个进程时间运行完内到达的进程,并且筛选出下一个最短的进程,此时第一个进程被标记为以调用。

     for(j=0;j<counter;j++)
     {
       if((process[j].come_time_hour<temp_time_hour)&&(!process[j].flag))
       {
         run_time=process[j].run_time;
         number_schedul=j;
         break;
       }
       else if((process[j].come_time_hour=temp_time_hour)&&(process[j].come_time_min<=temp_time_min)&&(!process[j].flag))
       {
          run_time=process[j].run_time;
          number_schedul=j;
          break;
       }
     }
    

    最后完成最短进程算法的调用

    分号&小数点之间的区别

    对于时间上的输入,我们往往是分为小数点和分号为间隔符的两种。
    如12点35可以表示成:12.35或者是12:35所以对于不同的间隔符号所使用的计算方法也会有些差别。
    首先创建task_struct结构体,在其中设置好进程所需的属性
    struct task_struct
    {
    int number; /进程编号/
    int come_time_hour;/到达时间/
    int come_time_min;
    int begin_time_hour; /开始运行时间/
    int begin_time_min;
    int run_time; /运行时间/
    int end_time_hour; /运行结束时间/
    int end_time_min;
    int end_time_mins;
    int priority; /优先级/
    int order; /运行次序/
    int flag; /调度标志/
    }process[MAX];

    分号时间调度算法

    对于分号上的输入首先应该对于到达时间的设置来进行分号前的小时和分号后的分钟的设置:come_time_hour为小时,come_time_min为分钟。
    到达时间
    在调度算法运算的过程中首先确保第一个进程开始的时间等于到来的时间

    process[number_schedul].begin_time_hour=process[number_schedul].come_time_hour;//第一个进程调度时间等于到来的时间 
    process[number_schedul].begin_time_min=process[number_schedul].come_time_min;//第一个进程调度时间等于到来的时间 
    

    之后开始进行时间上的叠加,即让到达时间加上运行时间,并且确保当分号后面的时间(分钟)超出60分时,进行小时的换算,并且让小时进行自增。
    实现代码如下

    process[number_schedul].end_time_min=process[number_schedul].begin_time_min+process[number_schedul].run_time;//第一个进程的结束时间等于运行时间加上开始的时间 
    process[number_schedul].end_time_hour=process[number_schedul].begin_time_hour;
    if(process[number_schedul].end_time_min>=60)
    {
     process[number_schedul].end_time_mins=process[number_schedul].end_time_min;
    	process[number_schedul].end_time_min = process[number_schedul].end_time_mins-((int)(process[number_schedul].end_time_mins/60)*60);
    	process[number_schedul].end_time_hour=process[number_schedul].begin_time_hour+(int)(process[number_schedul].end_time_mins/60);	
    }
    

    在这里面number_schedul代表的是经过筛选后选出的第一个进程的编号。
    首先判断process[number_schedul].end_time_min结束时间是否大于60如果是则进行process[number_schedul].end_time_hour小时位置上的累加,同时
    process[number_schedul].end_time_min也要进行除60之后的取余操作。其整数位为process[number_schedul].end_time_hour需要自增的数量。
    当第一个进程运行完之后进入下一轮的循环,并且此时后被队列进程数量减去第一个进程即将第一个进程标识为已经使用过。

    process[number_schedul].flag=1;//改程序已经运行一次所以运行标记修改为1 
    temp_time_hour=process[number_schedul].end_time_hour;//改时间作为结束时间  参与当下一程序进入后 检测下一程序  是否在上一个程序运行结束前进入 
    temp_time_min=process[number_schedul].end_time_min;
    process[number_schedul].order=1;//该进程的运行序列被排为第1个 
    temp_counter=1;//继续往该(最高优先级)进程下面检索下一个次于它的优先级进程
    

    之后通过temp_time_hour以及temp_time_min作为下一个进程的开始时间来进行筛选操作,其中应该确保下一个进程的开始时间是在上一个进程的结束时间内开始的所以要写出该条语句

       for(j=0;j<counter;j++) 
       {
         if((process[j].come_time_hour<temp_time_hour)&&(!process[j].flag))//当该进程再上一个进程结束之前开始且该进程没被调用过 
         {
            if (process[j].priority>max_priority) //检测该进程的优先级要大于当前进程优先级 
            { 
              max_priority=process[j].priority;//进程替换,优先级改变 
              number_schedul=j;
            }
         }
        else if((process[j].come_time_hour=temp_time_hour)&&(process[j].come_time_min<=temp_time_min)&&(!process[j].flag))
        {
            if (process[j].priority>max_priority) //检测该进程的优先级要大于当前进程优先级 
            { 
              max_priority=process[j].priority;//进程替换,优先级改变 
              number_schedul=j;
            }
    	}
       }  
    

    来对下一个进程的可运行性进行判断并且进行之后的运行时间开始时间相加操作,一直到后备队列进程运行完毕。

    周转时间

    在周转时间的运算上,首先当发现某进程到达时间和结束时间的分钟位置运算时小于零,则要在时刻位置上进行换算

       int decimal=process[i].end_time_min-process[i].come_time_min;//分钟 
       int integer=process[i].end_time_hour;//时刻 
       if(decimal<0)
       {
       	integer-=1;
       	decimal =process[i].end_time_min-process[i].come_time_min+60;
       	f1=(integer-process[i].come_time_hour)*60+decimal;
       }
    

    若到达时间小于结束时间的分钟位置则不需要进行换算,即周转时间进行正常的加减

       else if(decimal>=0)
       {
       	f1=(process[i].end_time_hour-process[i].come_time_hour)*60+(process[i].end_time_min-process[i].come_time_min);
       }
    

    f1为周转时间。

    小数点时间调度算法

    首先在对于进程到达时间的输入上小数点相较于分号而言更容易输入,首要不同的部分在于当开始时间以及运行时间相加时对于小数位置上的换算,
    对于小数部分当超过0.6之后自动视为超过60分钟则自动向整数位自增一
    同时保留余数作为分钟时刻。

    process[number_schedul].begin_time=process[number_schedul].come_time;//第一个进程调度时间等于到来的时间 
    process[number_schedul].end_time=process[number_schedul].begin_time+process[number_schedul].run_time;//第一个进程的结束时间等于运行时间加上开始的时间 
    decimal = process[number_schedul].end_time-(int)process[number_schedul].end_time;//小数部分
    if(decimal>=0.6)
    {
    	double remainder = decimal-((int)(decimal/0.6)*0.6);
    	process[number_schedul].end_time=(int)process[number_schedul].end_time+(int)(decimal/0.6)+remainder;
    }
    

    之后开始进行时间上的叠加,即让到达时间加上运行时间,并且确保当分号后面的时间(分钟)超出0.6时,进行整数位(小时)的换算,并且让小时进行自增。

    周转时间

    在最后的周转时间部分上进行相应的改动,当结束时间的小数位小于开始时间时,整数位自减并作为0.6的一个数值对小数部分进行换算,最后得出的小数值则为分钟位置的时间。
    double decimal = (process[i].end_time-(int)(process[i].end_time))-(process[i].come_time-(int)(process[i].come_time));//小数部分
    int integer=(int)process[i].end_time;
    if(decimal<0)
    {
    integer-=1;
    decimal = (process[i].end_time-(int)(process[i].end_time))-(process[i].come_time-(int)(process[i].come_time))+0.6;
    f1=integer-(int)process[i].come_time+decimal;
    }
    else if(decimal>=0)
    {
    f1=process[i].end_time-process[i].come_time;
    }

    展开全文
  • 优先级队列调度算法

    千次阅读 2008-10-31 15:58:00
    一、多优先级队列调度算法的描述该算法有多个队列,同一个队列中的进程优先级相同,不同队列中进程优先级不同;最高优先级上的进程运行1个时间片,次高优先级上的进程运行2个时间片,再下一级运行4个时间片,...
  • 1.编写程序模拟动态优先级进程调度算法,初始设置模拟5个进程调度,假设每个进程可有四种状态,分别为ready, running, waiting及terminated状态,并假定初始状态为ready状态。 2、在优先级调度算法中,各个进程的...
  • 最近学习了操作系统内诸多进程调度算法,动手实现了抢占式优先级调度算法 知识点 该算法又称为优先权调度算法,他既可以用于作业调度,又可用于进程调度。该算法中的优先级用于描述作业运行的紧迫程度。 两种类型: ...
  • /*抢占式优先级调度算法*/ #include <iostream> using namespace std; struct Num { int priority; //优先级 int dt; //到达时间 int st; //运行时间 int...
  • /*** 优先级调度算法* 抢占式 (单处理机)* @author ymj* @Date: 2019/12/15 22:53*/public class PSA2 {static Scanner cin = new Scanner(System.in);/** 进程控制块 */static class PCB implement...
  • 这次是用String的一位数组加上list来实现的,上一次写短进程优先的时候,认为用date类太麻烦了。所以这次直接用String,没想到,还是一样的麻烦,因为我想要表示小时,分钟,秒数,三个时间单位,而不是两个时间单位...
  • 操作系统中进程调度是处理及管理的核心内容。 阅读本文,需要有一定的C/C++、数据结构基础。 内容介绍 采用C++编写程序,选用优先数调度算法或简单轮转法对五个进程进行调度,每个进程处于运行(Run)、就绪...
  • 本程序是用单链表对列来管理资源(进程),实现了对进程优先级调度
  • 抢占式SJF三、优先级调度算法1. 非抢占式优先级调度算法2. 抢占式优先级调度算法四、时间片轮转(RR)算法五、多级队列调度 一、先来先服务(FCFS)调度算法 非抢占式调度,选择就绪队列中等待最长时间的进程。 ...
  • 进程类:import java.text.ParseException;import java.text.SimpleDateFormat;import java.util.Comparator;import java.util.Date;public class Process implements Comparable {private String mName; //线程名 ...
  • 实现四种不同及进程调度算法: 先来先服务、时间片轮转调、优先级调度以及短作业优先调度算法。 ////1、 算法流程 ////抽象数据类型的定义:PCB块结构体类型 //struct PCB //{ // int name; // int arrivetime; //...
  • 但实际情况并非如此,为了能满足实际情况的需要,在进程调度算法中引入优先级,而形成优先级调度算法。本例中实现的优先级的定义为:优先数 = 50 - 运行时间每运行一次优先数减3,重新竞争。实现效果:(只列出输入和...
  • PAGE / NUMPAGES 优先级调度算法 1调度算法 考虑到紧迫型作业进入...当该算法用于进程调度时,将把处理机分配给就绪进行队列中优先级最高的进程 2调度算法的两种方式 非抢占式优先级算法在这种调度方式下,系统一旦把处理
  • 进程调度算法有很多,例如先来先服务调度算法(FCFS),短作业优先算法(SJF),时间片轮转算法(RR)和优先级算法,这里我将通过代码的方式主要介绍轮转调度算法(RR)和动态优先级调度算法.      ...
  • 优先级调度算法,是把处理机分配给就绪队列中优先级最高的进程。其中又可进一步把该算法分为下面两种。 1、非抢占式优先级调度算法。该算法规定,一旦处理机分配给就绪队列中优先级最高的进程后,该进程便一直执行...
  • 先来先服务、时间片轮转调、优先级调度以及短作业优先调度算法。 1.主程序中从文件中得到进程数量,创造pcb,creat()从文件中得到进程数据如下:name。调用Layout()显示选择界面。 2.Layout()函数中选择相应的算法并...
  • //进程调度 int dosth(int x); //占用cpu执行任务 //空闲队列 struct free{ int fhead; //空闲队列头 int ftail; //空闲队列尾 }free01; struct prepare{ int phead; //就绪队列头 int ptail; //就绪队列尾 }...

空空如也

空空如也

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

优先级进程调度算法