java实进程调度

进程调度方式：非抢占式、抢占式

非抢占式：一旦处理机分配给某进程后，不管它运行多久让他一直运行下去，不会因为时钟中断等原因而抢占正在运行的处理机。直到该进程完成，自愿放弃处理机，或阻塞时
非抢占式算法有：先来先服务（FCFS）、短作业优先调度算法(SJ( P )F)、高优先权优先调度算法

抢占式：允许调度程序根据某种原则去暂停某个正在执行的进程。抢占调度方式有一定原则，主要有以下几条：

1. 优先权原则
2. 短作业优先原则
3. 时间片原则
   抢占式算法有：时间片轮转算法、多级反馈队列调度算法

先来先服务算法（FCFS）：先来先服务算法是一种最简单的算法，可用于进程调度，也可用于作业调度。如名，进程调度采用FCFS算法时，每次调度都是从就绪队列中选取一个最先进入队列的进程，分配处理及，该进程一直运行到完成或者发生事件而阻塞才放弃处理机。
该算法比较利于长作业（进程），不利于短作业；原因：短作业等待时间过长
该算法有利于CPU繁忙型（指需要大量cpu时间）的作业，不利于I/O繁忙型

PCB temppcb1,temppcb2,temppcb3;  
        int count1=queue.size();  
        int count2=queue.size()-1;  
        LinkedList<PCB> queueQ=new LinkedList<PCB>();  
        while(count1>0){  
            temppcb3=temppcb1=queue.poll();  
            count1--;  
            while(count2>0){  
                temppcb2=queue.poll();  
                count2--;  
                if(temppcb2.pri>=temppcb1.pri)//优先权  
                {  
                    queue.offer(temppcb2);  
                }  
                else  
                {  
                    queue.offer(temppcb1);  
                    temppcb1=new PCB();  
                    temppcb1=temppcb2;  
                }  
            }  
            queue.offer(temppcb1);  
            count2=queue.size()-1;  
        }  

短作业优先调度算法(SJ( P )F)：短作业优先调度算法是指对短作业或短进程优先调度的算法，从就绪队列中找到预计最短运行时间的进程，让处理机调度它
优点：可以有效降低作业的平均等待时间，提高系统吞吐量。
缺点：对长作业不利，周转时间与带权周转时间提升。未考虑作业的紧迫程度。时间长短是估计的，所以不一定会达到真正的短作业调度

if(rpcb!=null)  
        {  
            if(rpcb.allt==0)  
            {  
                rpcb.state="OVER";  
                overqueue.offer(rpcb);  
                rpcb=readyqueue.poll();  
                rpcb.state="EXECUTE";  
                rpcb.allt--;  
                rpcb.cput++;  
                rpcb.pri=rpcb.pri-3;  
            }  
            else  
            {  
                if(judgePri(readyqueue))  
                {  
                    rpcb.state="BLOCK";  
                    blockqueue.offer(rpcb);  
                    rpcb=readyqueue.poll();  
                    rpcb.state="EXECUTE";  
                      
                }  
                rpcb.allt--;  
                rpcb.cput++;  
                rpcb.pri=rpcb.pri-3;  
            }  
            readyqueueUpdate(readyqueue);  
            blockqueueUpdate(blockqueue);  
        }  
        else  
        {  
            rpcb=readyqueue.poll();  
            rpcb.allt--;  
            rpcb.cput++;  
            rpcb.pri=rpcb.pri-3;  
            rpcb.state="EXECUTE";  
              
            readyqueueUpdate(readyqueue);  
            blockqueueUpdate(blockqueue);  
        }  

高优先权优先调度算法：类同于短作业优先调度算法

int count=queue.size();  
        PCB tempPcb;  
        while(count>0)  
        {  
            count--;  
            tempPcb=queue.poll();  
            tempPcb.endblock--;  
            if(tempPcb.endblock==0)  
            {  
                tempPcb.endblock=3;  
                tempPcb.state="READY";  
                readyqueue.offer(tempPcb);  
                readyqueueSort(readyqueue);//使得刚转移过来的进程参与优先权竞选  
            }  
            else{  
                queue.offer(tempPcb);  
            }  
              
        }  
        blockqueueSort(blockqueue); 

时间片轮转算法：利用FCFS再令其执行一个时间片，时间片用完时，发生中断，将其送入就绪队列尾部

public void tsc(List<PCB> pcbs){
		while(!isFinish(pcbs)){
			//获取所有进程数
			Long count = pcbs.stream().filter((e)->e.getStatus().equals(Status.W)).collect(Collectors.counting());
			for(int i = 0;i<count;i++){
				//获取应调度的进程
				Optional<PCB> op = pcbs.stream()
						   .filter((e)->e.getStatus().equals(Status.W))
						   .skip(i)
						   .findFirst();
				op.get().setStatus(Status.R);
				op.get().run(10);
				try {
					Thread.sleep(500);
				} catch (InterruptedException e1) {
					e1.printStackTrace();
				}
				System.out.println("CPU运行时间:"+PCB.run_time);
				show(Status.F);
				show(Status.R);
				show(Status.W);
				show(Status.H);
				System.out.println();
				//时间片完后把执行状态转换为就绪状态
				if(op.get().getStatus().equals(Status.R)){
					op.get().setStatus(Status.W);
				}else{
					count --;
				}
			}
		}
	}

多级反馈队列调度算法：既能使高优先级的作业得到响应又能使短作业（进程）迅速完成

public void hrr(List<PCB> pcbs){
		while(!isFinish(pcbs)){
			//获取当前相对优先级最高的进程
			Optional<PCB> op = pcbs.stream()
								   .filter((e)->e.getStatus().equals(Status.W))
								   .max((e1,e2)->Double.compare(e1.hrr_priority(), e2.hrr_priority()));
			op.get().setStatus(Status.R);
			op.get().run(10);
			try {
				Thread.sleep(500);
			} catch (InterruptedException e1) {
				e1.printStackTrace();
			}
			System.out.println("CPU运行时间:"+PCB.run_time);
			show(Status.F);
			show(Status.R);
			show(Status.W);
			show(Status.H);
			System.out.println();
			if(op.get().getStatus().equals(Status.R)){
				op.get().setStatus(Status.W);
			}
		}
	}