java 优先级进程调度_优先级调度算法如何用JAVA实现

最新推荐文章于 2024-03-22 21:42:33 发布
最新推荐文章于 2024-03-22 21:42:33 发布
阅读量369 收藏
点赞数
文章标签： java 优先级进程调度
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_35727143/article/details/114211566
版权
这是一个关于如何使用 Java 代码实现动态优先级抢占式调度算法的示例。代码中包括了进程状态枚举、进程结构、多道处理系统的数据结构以及一系列相关函数，如初始化、插入进程、更新系统等。程序还包含一个简单的图形界面用于展示系统状态。
摘要由CSDN通过智能技术生成

展开全部

没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==

已赞过

已踩过<

你对这个回答的评价是？

评论

收起

蝌蚪们都在想
关注
进程调度优先级JAVA_进程调度-优先级算法（Java简单实现）
weixin_39526741的博客
02-16 631
在时间片轮转调度算法中，做了一个隐含的假设，即系统中所有进程的紧迫性是相同的。但实际情况并非如此，为了能满足实际情况的需要，在进程调度算法中引入优先级，而形成优先级调度算法。本例中实现的优先级的定义为：优先数 = 50 - 运行时间每运行一次优先数减3，重新竞争。实现效果：(只列出输入和最终输出，省略中间过程)Java实现过程PCB类在比起时间片轮转算法中新增一个priorityNumber(省略...
java 优先数调度算法实现处理器调度的程序
12-14
处理器调度 java 优先数调度算法实现处理器调度的程序
java按优先权调度进程算法实现
yinfuhao的专栏
12-01 2751
public class OSProcess{ private String name; //进程名 private OSProcess next;//指向下一个进程 private int run_time; //要求运行时间 private int allo_time;//已运行时间 private int req_time;//还需要运行时间 private char state
优先数调度算法
06-30
模拟计算机的处理机调度。按优先级调度算法实现处理机调度。
java实现优先级调度算法_操作系统程序调度算法——先来先服务（FCFS），时间片（RR），短作业（SJF），高响应比（HRRN）java实现...
weixin_39928233的博客
02-13 573
操作系统实验——程序调度操作系统实验要求写程序调度，百度查了一下，借鉴了一位老哥的先来先服务，自己写了后面的先来先服务只要写一个循环，把process集合中的每个process取出，把process结束时间置为当前时间加上服务时间，然后当前时间加上服务时间即可。private void calc() {int timeNow = 0;Process opProcess;for (int i = 0...
cpu.rar_CPU 调度_优先级调度_优先级调度算法_调度算法
09-24
4. **模拟与实现**：描述中提到的"操作系统CPU优先级调度算法的模拟"可能是指通过编程实现对各种优先级调度算法的模拟，如使用`CPUPriority.dsp`、`CPUPriority.cpp`等项目文件创建一个模拟环境，模拟进程的生成、...
操作系统——动态优先级调度算法源代码.rar_优先级_优先级调度_优先级调度算法_动态优先级_动态优先级 算法
09-20
操作系统——动态优先级调度算法源代码，多道系统中多进程并发执行，为了提高系统性能解决进程死锁问题，进程的优先级是动态变化的。正在执行的进程优先级会随时间降低，而挂起的进程或等待的进程的优先级会逐渐升高...
main_进程调度_操作系统优先级进程调度算法_
09-29
非抢占式优先级调度算法是其中一种常见的策略，它基于每个进程的优先级来决定执行顺序。在这个算法中，优先级高的进程将优先得到CPU。优先级可以基于各种因素设置，如进程类型、等待时间、I/O需求等。这种算法简单...
操作系统——PCB模拟.rar_优先级调度_优先级调度算法_控制台_进程调度 图形
09-22
本资源提供了对PCB（Process Control Block，进程控制块）进行模拟的程序，特别关注了优先级调度算法的实现。 优先级调度是一种常见的调度策略，通过为每个进程分配一个优先级来决定哪个进程应该被优先执行。在这个...
jinchengdiaodu.zip_优先级 调度_优先级调度_进程调度
09-14
在实际操作系统中，除了优先级调度外，还有其他调度算法，如轮转调度、短进程优先（SPF）等。每种算法都有其适用场景，理解并掌握这些调度策略对于优化系统性能至关重要。 综上所述，"jinchengdiaodu.zip"中的实验...
java设计一个按优先数调度算法实现处理器调度的程序。
07-23
java 优先数调度 处理器调度 java设计一个按优先数调度算法实现处理器调度的程序。
进程调度的两种算法JAVA实现----FCFS(先来先服务)和SJF(最短作业优先)
06-19
进程调度的两种算法JAVA实现----FCFS(先来先服务)和SJF(最短作业优先) 直接能运行，完整版本，jdk 1.6就行
实现进程调度算法---动态优先级
10-27
试验名称：进程调度模拟算法 试验内容：设计一个有N个进程并行的进程调度程序。 调度算法：采用最高优先数优先的调度算法。每个进程由一个进程控制块（PCB）表示。进程控制块可以包含以下信息：进程名、优先数、到达时间、需要运行时间、已用CPU时间，进程状态等。
java实现优先级调度算法
qq_55915890的博客
03-25 2935
java实现优先级调度算法 Time类： package 优先级进程调度算法; public class time { private int hour; private int min; public int getHour() { return hour; } public void setHour(int hour) { this.hour = hour; } public int getMin() {
优先级调度算法（非抢占式）Java实现
最新发布
qq_74374916的博客
03-22 1351
在该算法中，由于在9：40时刻系统中只有作业p1,因比系统将优先为作业p1进行调度。作业p1在完成的过程中作业p2、p3、p4、p5先后都到达了系统中。也就是说在作业p1调度完成后系统中会有p2、p3、p4、p5四个作业等待调度。，系统将依次按p2、p4、p5、p3的顺序为接下来的四个作业进行调度。下述具体的计算可以参考本人FCFS算法的具体内容，此处不过多叙述（假设现在有五个进程先后到达系统进行调度。
用JAVA实现优先级调度算法
DIGUA的博客
11-02 2390
参考文章： https://blog.csdn.net/qq_41900081/article/details/85275060 https://blog.csdn.net/abc1498880402/article/details/80372441 一、实验目的 在采用多道程序设计的系统中，往往有若干个进程同时处于就绪状态。当就绪进程个数大于处理机数时，就必须依照某种策略来决定哪些进程优先占用处理机。本实验模拟在单处理机情况下的进程调度，帮助学生加深了解进程调度的工作。 二、实验内容 设计一个按优先级.
高优先权优先调度算法（java实现）
可行的code
04-14 8824
目录 1、算法思想 2、算法主要类 2.1建立job.java类 2.2主方法类DynamicJobFirst.java类 2.3工具类DynamicJobFirstUtil。 3、算法执行结果 优先级调度的含义 （1）当该算法用于作业调度时，系统从后备作业队列中选择若干个优先级最高的，且系统能满足资源要求的作业装入内存运行。 （2）当该算法用于进程调度时，将把处理机分配给...
操作系统优先级调度算法java实现
qq_47425497的博客
05-23 700
操作系统优先级调度算法java实现
动态优先级算法（java实现）
我家有只小金毛的博客
11-02 4212
Java实现动态优先级算法算法导入实验要求实验流程图算法分析算法设计算法调试结尾感言 算法导入 最近在学操作系统，老师的第一个实验要求——实现动态优先级进程调度算法。在度娘上也搜到了些，借鉴了一位大佬的设计思想，用java实现了简单的一个进程调度算法。 实验要求 1. 采用最高优先数的调度算法（即把处理机分配给优先数最高的进程）。 注：数字越小，优先级越高，当然我偷懒都设为正整数，你好我好大家好！...
Java实现优先级调度算法：处理器调度程序设计
在这个实验中，我们将使用Java语言实现一个简单的优先数调度算法。优先数调度算法是一种非抢占式调度算法，它按照进程的优先级分配处理器资源，优先级高的进程优先执行。以下是对该程序设计的详细说明： 1. **进程...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值