计算机操作系统进程调度五种算法为：1.先来先服务算法 2.短作业优先算法 3.高响应比优先算法 4.时间片轮转法 5.多级反馈队列算法
public class jcdu {
String name;
int id;
int enter_time;
int ser_time;
jcdu(){}
void setname(String aname){
this.name=aname;
}
void setenter_time(int time){
this.enter_time=time;
}
void setser_time(int time){
this.ser_time=time;
}
void setid(int id){
this.id=id;
}
String getname(){
return this.name;
}
int getenter_time(){
return this.enter_time;
}
int getser_time(){
return this.ser_time;
}
int getid(){
return this.id;
}
}1.先来先服务算法：主要为每次调度作业就是从后备的就绪队列中就是选择一个或者多个最先进入该队列的作业。可以设置一个静态变量，让静态变量逐渐递增，用一个List容器判断每秒中进入就绪队列中的作业。当一个作业执行完毕，再从List容器选出第一个进入该队列的作业。一直循环到所有作业执行完毕。
/*先来先服务*/ class test{
public static int run_time=0;
public static void main(String[] args) {
jcdu [] temp=new jcdu[5];
Scanner in=new Scanner(System.in);
int pro_count=0;
int do_time=0;
int en_time;
int do_id=0;
String name=null;
System.out.println("请输入进程信息:");
for(int i=0;i<5;i++){
System.out.println("进程id"+i);
temp[i]=new jcdu();
temp[i].setid(i);
System.out.print("进程名:");
temp[i].setname(in.next());
System.out.print("到达时间：");
temp[i].setenter_time(in.nextInt());
System.out.print("服务时间：");
temp[i].setser_time(in.nextInt());
}
List <jcdu>li=new ArrayList<jcdu>();
for(jcdu x:temp){
li.add(x);
}
while(true){
int j;
en_time=Integer.MAX_VALUE;
for(jcdu x:li){
if(x.getenter_time()< en_time){ //找出一个执行进程
do_id=x.getid();
do_time=x.getser_time();
name=x.getname();
en_time=x.getenter_time();
}
}
if(en_time>run_time){
System.out.println("当前没有进程到达");
run_time++;
}
else{
for(j=0;j<do_time;j++){
for(jcdu x:li){
if(x.getenter_time()==run_time){
System.out.println("进程"+x.getname()+"在第"+run_time+"秒到达");
}
}
System.out.println("第"+run_time+"秒"+"执行进程"+name);
try {
Thread.currentThread().sleep(1000);
}
catch (InterruptedException e) {
e.printStackTrace();
}
run_time++;
}
if(j==do_time){
System.out.println(name+"进程执行结束");
}
pro_count++;
for(int i=0;i<li.size();i++){
if(li.get(i).getid()==do_id){
li.remove(i);
}
}
if(pro_count==5)
break;
}
}
try {
Thread.currentThread().sleep(1000);
}
catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("进程信息");
show(temp);
}
public static void show(jcdu [] other){
System.out.printf("%-5s %-5s %-5s %-5s\n","进程id","进程名","到达时间","服务时间");
for(jcdu x:other){
System.out.printf("%-5d %-5s %-5s %-5s\n",x.getid(),x.getname(),x.getenter_time(),x.getser_time());
}
}
}2.短作业优先算法：主要为每次调度作业就是从后备的就绪队列中就是选择一个或者多个要求服务时间最短的作业。可以设置一个静态变量，让静态变量逐渐递增，用一个List容器判断每秒中进入就绪队列中的作业。当一个作业执行完毕，再从List容器选出服务时间最短的进入该队列的作业。一直循环到所有作业执行完毕。
class test{
public static int run_time=0;
public static void main(String[] args) {
jcdu [] temp=new jcdu[5];
Scanner in=new Scanner(System.in);
int pro_count=0;
int ser_time;
int en_time=0;
int do_id=0;
String name=null;
System.out.println("请输入进程信息:");
for(int i=0;i<5;i++){
System.out.println("进程id"+i);
temp[i]=new jcdu();
temp[i].setid(i);
System.out.print("进程名:");
temp[i].setname(in.next());
System.out.print("到达时间：");
temp[i].setenter_time(in.nextInt());
System.out.print("服务时间：");
temp[i].setser_time(in.nextInt());
}
List <jcdu>li=new ArrayList<jcdu>();
for(jcdu x:temp){
li.add(x);
}
while(true){
int j;
ser_time=Integer.MAX_VALUE;
for(jcdu x:li){
if(x.getenter_time()<=run_time && x.getser_time()< ser_time){ //找出一个执行进程
do_id=x.getid();
ser_time=x.getser_time();
name=x.getname();
en_time=x.getenter_time();
}
}
if(en_time>run_time){
System.out.println("当前没有进程到达");
run_time++;
}
else{
for(j=0;j<ser_time;j++){ //根据执行时间
for(jcdu x:li){
if(x.getenter_time()==run_time){
System.out.println("进程"+x.getname()+"在第"+run_time+"秒到达");
}
}
System.out.println("第"+run_time+"秒"+"执行进程"+name);
try {
Thread.currentThread().sleep(1000);
}
catch (InterruptedException e) {
e.printStackTrace();
}
run_time++;
}
if(j==ser_time){
System.out.println(name+"进程执行结束");
}
pro_count++;
for(int i=0;i<li.size();i++){
if(li.get(i).getid()==do_id){
li.remove(i);
}
}
if(pro_count==5)
break;
}
}
try {
Thread.currentThread().sleep(1000);
}
catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("进程信息");
show(temp);
}
public static void show(jcdu [] other){
System.out.printf("%-5s %-5s %-5s %-5s\n","进程id","进程名","到达时间","服务时间");
for(jcdu x:other){
System.out.printf("%-5d %-5s %-5s %-5s\n",x.getid(),x.getname(),x.getenter_time(),x.getser_time());
}
}
}3.高响应比优先算法：主要为每次调度作业就是从后备的就绪队列中就是选择一个或者多个响应比最高的作业。可以设置一个静态变量，让静态变量逐渐递增，用一个List容器判断每秒中进入就绪队列中的作业，并且每秒计算该作业的响应比｛（等待时间+要求服务时间）/要求服务时间｝。当一个作业执行完毕，再从List容器选出响应比最高的作业。一直循环到所有作业执行完毕。
class test{
public static int run_time=0;
public static void main(String[] args) {
jcdu [] temp=new jcdu[5];
Scanner in=new Scanner(System.in);
int pro_count=0;
int ser_time=0;
int en_time=0;
int do_id=0;
String name=null;
System.out.println("请输入进程信息:");
for(int i=0;i<5;i++){
System.out.println("进程id"+i);
temp[i]=new jcdu();
temp[i].setid(i);
System.out.print("进程名:");
temp[i].setname(in.next());
System.out.print("到达时间：");
temp[i].setenter_time(in.nextInt());
System.out.print("服务时间：");
temp[i].setser_time(in.nextInt());
}
List <jcdu>li=new ArrayList<jcdu>();
for(jcdu x:temp){
li.add(x);
}
while(true){
int j;
double wei=Double.MIN_VALUE;
for(jcdu x:li){
x.setweight(run_time);
}
for(jcdu x:li){
if(x.getenter_time()<=run_time && x.getweight()>wei){ //找出一个执行进程
do_id=x.getid();
ser_time=x.getser_time();
name=x.getname();
en_time=x.getenter_time();
wei=x.getweight();
}
}
if(en_time>run_time){
System.out.println("当前没有进程到达");
run_time++;
}
else{
for(j=0;j<ser_time;j++){ //根据执行时间
for(jcdu x:li){
if(x.getenter_time()==run_time){
System.out.println("进程"+x.getname()+"在第"+run_time+"秒到达");
}
}
System.out.println("第"+run_time+"秒"+"执行进程"+name);
try {
Thread.currentThread().sleep(1000);
}
catch (InterruptedException e) {
e.printStackTrace();
}
run_time++;
}
if(j==ser_time){
System.out.println(name+"进程执行结束");
}
pro_count++;
for(int i=0;i<li.size();i++){
if(li.get(i).getid()==do_id){
li.remove(i);
}
}
if(pro_count==5)
break;
}
}
try {
Thread.currentThread().sleep(1000);
}
catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("进程信息");
show(temp);
}
public static void show(jcdu [] other){
System.out.printf("%-5s %-5s %-5s %-5s\n","进程id","进程名","到达时间","服务时间");
for(jcdu x:other){
System.out.printf("%-5d %-5s %-5s %-5s\n",x.getid(),x.getname(),x.getenter_time(),x.getser_time());
}
}
}4.时间片轮转算法：主要为每次调度作业就是从后备的就绪队列中就是选择一个或者多个最先进入该队列的作业。每次給队列首元素分配时间片，当时间片执行完毕时，再把进程放到队尾。一直循环到所有作业执行完毕。
class test{
public static int run_time=0;
public static void main(String[] args) {
jcdu [] temp=new jcdu[5];
Scanner in=new Scanner(System.in);
int pro_count=0;
int en_time=0;
int time_p=0;
String name=null;
System.out.println("请输入进程信息:");
for(int i=0;i<5;i++){
System.out.println("进程id"+i);
temp[i]=new jcdu();
temp[i].setid(i);
System.out.print("进程名:");
temp[i].setname(in.next());
System.out.print("到达时间：");
temp[i].setenter_time(in.nextInt());
System.out.print("服务时间：");
temp[i].setser_time(in.nextInt());
}
System.out.println("请输入时间片的长度 :");
time_p=in.nextInt();
List <jcdu>li=new ArrayList<jcdu>();
while(true){
int j;
int i;
int q=0;
for(i=0;i<temp.length;i++)
{
if(temp[i].getenter_time() == run_time) //判读是否有进程进入队列
{
System.out.println(run_time+"进程"+temp[i].getname()+"进入就绪队列");
li.add(temp[i]);
}
}
if(li.isEmpty())
{
System.out.println(run_time+"没有可执行性进程");
}
else
{
jcdu te=li.get(0);
li.remove(0);
for(j=0;j<time_p;j++)
{
name=te.getname();
System.out.println("第"+run_time+"秒"+"执行进程"+name);
te.setdoingtime();
try {
Thread.currentThread().sleep(1000);
}
catch (InterruptedException e) {
e.printStackTrace();
}
if(te.com())
{
pro_count++;
System.out.println("第"+run_time+"秒"+"进程"+name+"执行结束");
if(li.isEmpty())
{
System.out.println("就绪队列为空");
for(i=0;i<temp.length;i++)
{
if(temp[i].getenter_time() == run_time) //判读是否有进程进入队列
{
System.out.println(run_time+"进程"+temp[i].getname()+"进入就绪队列");
li.add(temp[i]);
}
}
}
else
{
te=li.get(0);
li.remove(0);
}
}
run_time++;
System.out.print("就绪队列：");
for(jcdu x:li){
System.out.print(x.getname()+" ");
}
System.out.println(" ");
}
if(!te.com())
li.add(te);
System.out.println("时间片执行完毕");
System.out.println();
}
if(pro_count==5)
break;
}
/*int j;
int q=0;
double wei=Double.MIN_VALUE;
en_time=Integer.MAX_VALUE;
for(int i=0;i<temp.length;i++){
if(temp[i].getenter_time() == run_time){ //判读是否有进程进入队列
for(jcdu x:li){
if(x.getname()!=temp[i].getname())
q++;
}
if(q==li.size()){
li.add(temp[i]);
}
}
System.out.print("就绪队列：");
for(jcdu x:li){
System.out.print(x.getname()+" ");
}
System.out.println(" ");
if(li.isEmpty()){
System.out.println("当前就绪队列为空");
run_time++;
}
else{
jcdu te=li.get(0);
li.remove(0); //取出当前执行的队首元素
for(j=0;j<time_p;j++){
name=te.getname();
System.out.println("第"+run_time+"秒"+"执行进程"+name);
try {
Thread.currentThread().sleep(1000);
}
catch (InterruptedException e) {
e.printStackTrace();
}
te.setdoingtime(); //已经执行的时间
if(te.com()){ //已经执行完毕 重新选取队首元素
System.out.println(name+"进程执行结束");
pro_count++;
if(li.isEmpty()){
System.out.println("就绪队列已空");
}
else{
te=li.get(0);
li.remove(0);
}
}
run_time++;
for(int pi=0;pi<temp.length;pi++){
if(temp[pi].getenter_time() == run_time){ //判读下一秒是否有进程进入队列
System.out.println("第"+run_time+"秒到达"+temp[pi].getname());
li.add(temp[pi]);
}
}
}
if(!te.com()) //如果时间片结束进程还没有执行行结束从新放入队尾元素
li.add(te);
}
if(pro_count==5)
break;
}
}*/
}
public static void show(jcdu [] other){
System.out.printf("%-5s %-5s %-5s %-5s\n","进程id","进程名","到达时间","服务时间");
for(jcdu x:other){
System.out.printf("%-5d %-5s %-5s %-5s\n",x.getid(),x.getname(),x.getenter_time(),x.getser_time());
}
}
}5.多级反馈队列算法：设置多个队列，每个队列的时间片长度不同，当队列1中作业未执行完毕时，在放入二级队列依次类推。一直循环到所有作业执行完毕。
class test{
public static int run_time=0; //运行时间
static int pro_count=0; //进程完成数
int ser_time=0; //要求服务时间
int en_time; //到达时间
String name=null;
static jcdu [] temp={
new jcdu("A",1,0,3),new jcdu("B",2,2,6),
new jcdu("C",3,4,4),new jcdu("D",4,6,5),
new jcdu("E",5,8,2)};
public static void main(String[] args) {
duojiqueue();
}
public static void duojiqueue(){
List <jcdu> li1=new ArrayList<jcdu> ();
List <jcdu> li2=new ArrayList<jcdu> ();
Map<Integer,List <jcdu> > tmap=new HashMap<Integer,List <jcdu>>();
tmap.put(2,li1);
tmap.put(4,li2);
while(pro_count!=5){
for(int i=0;i<temp.length;i++)
{
if(temp[i].getenter_time() == run_time) //判读是否有进程进入队列
{
System.out.println(run_time+"秒进程"+temp[i].getname()+"进入就绪队列1");
li1.add(temp[i]);
}
}
Set<Integer> keys=tmap.keySet();
Iterator<Integer> i=keys.iterator();
while(i.hasNext()){
int key=i.next();
List <jcdu> li=tmap.get(key);
System.out.print("就绪队列"+key/2);
if(!li.isEmpty())
{
for(jcdu r:li)
System.out.print(r.getname());
}
System.out.println();
}
while(!li1.isEmpty()){
jcdu r=li1.get(0);
li1.remove(r);
for(int j=0;j<2;j++)
{
System.out.println("当前时间片执行进程"+r.getname());
r.addser_time();
try {
Thread.currentThread().sleep(1000);
}
catch (InterruptedException e) {
e.printStackTrace();
}
if(r.isequ()){
System.out.println("进程执行结束"+r.getname());
pro_count++;
break;
}
run_time++;
for(int w=0;w<temp.length;w++)
{
if(temp[w].getenter_time() == run_time) //判读是否有进程进入队列
{
System.out.println(run_time+"进程"+temp[w].getname()+"进入就绪队列1");
li1.add(temp[w]);
}
}
}
if(!r.isequ()){
li2.add(r);
}
keys=tmap.keySet();
i=keys.iterator();
while(i.hasNext()){
int key=i.next();
List <jcdu> li=tmap.get(key);
System.out.print("就绪队列"+key/2);
if(!li.isEmpty())
{
for(jcdu rw:li)
System.out.print(rw.getname());
}
System.out.println();
}
}
while(!li2.isEmpty()){
jcdu r=li2.get(0);
li2.remove(r);
for(int j=0;j<4;j++)
{
System.out.println("当前时间片执行进程"+r.getname());
r.addser_time();
try {
Thread.currentThread().sleep(1000);
}
catch (InterruptedException e) {
e.printStackTrace();
}
if(r.isequ()){
System.out.println("进程执行结束"+r.getname());
pro_count++;
break;
}
run_time++;
for(int w=0;w<temp.length;w++)
{
if(temp[w].getenter_time() == run_time) //判读是否有进程进入队列
{
System.out.println(run_time+"进程"+temp[w].getname()+"进入就绪队列1");
li1.add(temp[w]);
}
}
}
if(!r.isequ()){
li2.add(r);
}
keys=tmap.keySet();
i=keys.iterator();
while(i.hasNext()){
int key=i.next();
List <jcdu> li=tmap.get(key);
System.out.print("就绪队列"+key/2);
if(!li.isEmpty())
{
for(jcdu rw:li)
System.out.print(rw.getname());
}
System.out.println();
}
}
}
System.out.println(run_time);
}
}
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
