SJF短作业进程优先调度算法

短作业（进程）优先调度算法

1. 短作业（进程）优先（Shortest Job First，SJF或Shortest Process Next，SPN）是指对短作业或短进程优先调度的算法。该算法可分别用于作业调度和进程调度。该算法的设计目标是改进FCFS算法，减少作业或进程的平均周转时间。
2. SJF算法要求作业在开始执行之前预计作业的执行时间，对预计执行时间短的作业优先调入内存。
3. SJF算法和FCFS算法进行比较，SJF有以下优点：
   1）改善了平均周转时间和平均带权周转时间，缩短了等待时间；
   2）有利于提高系统的吞吐量。
   同样具有以下几个缺点：
   1）对长作业或进程不利；
   2）该算法没有考虑作业或进程的紧迫程度，因而不能保证紧迫的作业或进程得到及时处理或相应；
   3）由于作业或进程的执行时间是用户估计的，因而准确性不高，从而影响调度性能；
   4）如果系统中持续有更短作业或最短进程出现，可能导致长作业或进程被饿死，即永远得不到执行。

SJF算法的具体实现

1. SJF的代码（个人的思想不同所以写出来的代码也不一样，仅供参考学习）：

void SJF()
{  
	cout<<"SJF调度算法:"<<endl;
	int i,j,min_time,index;
    int  last_finishedPCB_index;    //记录上一次已经运行的进程的数组下标
   
     // 运行第一个到达的进程  得到它的完成时间、周转时间等,并设置为已访问
	 pcb[0].finish_time=pcb[0].arrive_time+pcb[0].run_time;
	 pcb[0].zhouzhuan_time=pcb[0].finish_time-pcb[0].arrive_time;
	 pcb[0].daiquan_time=(float)pcb[0].zhouzhuan_time/pcb[0].run_time;
      pcb[0].finished=true;
     last_finishedPCB_index=0; 

     //下面在剩下的进程中循环找出运行时间最小的进程，
     //计算它的完成时间、周转时间等，并设置为已访问。 
	 //先找出没有访问过的运行时间最小的进程的下标
       for(i=0;i<N;i++)
	   {     
	    index=-1;
	    min_time=100;
        for(j=0;j<N;j++)
		{
			if(min_time>pcb[j].run_time&&pcb[j].finished==false&&pcb[j].arrive_time<=pcb[last_finishedPCB_index].finish_time)
			{
				min_time=pcb[j].run_time;
				index=j;
			}
		}

		if(pcb[index].arrive_time<=pcb[last_finishedPCB_index].finish_time)
		{
			pcb[index].finish_time=pcb[last_finishedPCB_index].finish_time+pcb[index].run_time;
			pcb[index].zhouzhuan_time=pcb[index].finish_time-pcb[index].arrive_time;
			pcb[index].daiquan_time=(float)pcb[index].zhouzhuan_time/pcb[index].run_time;
		}
		if(pcb[index].arrive_time>pcb[last_finishedPCB_index].finish_time)
		{
			pcb[index].finish_time=pcb[index].arrive_time+pcb[index].run_time;
			pcb[index].zhouzhuan_time=pcb[index].run_time;
			pcb[index].daiquan_time=(float)pcb[index].zhouzhuan_time/pcb[index].run_time; 
		}
		pcb[index].finished =true;
		last_finishedPCB_index=index;
	}  

    for(i=0;i<N;i++)
		{
			sumzhouzhuantime+=pcb[i].zhouzhuan_time;
			sumdaiquanzhouzhuantime+=pcb[i].daiquan_time;
		}
}

先计算第一个进程的各项时间，将时间全部求解出来。在结构体里设置一个标志，初始化将进程的标志全部设为false，访问过的进程设为ture，在下一次选择运行时间最短的进程时不访问它。在选择最短进程时，优先访问运行时间最小的进程，并比较到达时间与上一个进程完成时间，如果小于，则完成时间等于运行时间加上一个进程的完成时间；如果下一个进程的到达时间大于上一个进程的完成时间，则此进程的完成时间为到达时间加运行时间。

1. 考虑到某进程的运行时间最短，但它还没有到达的情况，设计一个循环限制条件为程序的到达时间小于上一个进程的完成时间，在剩下的进程里面找到运行时间最短的进程，将此进程设置为index。这时计算时间有两种情况：
   1）下一个进程的到达时间小于上一个进程的完成时间，则各时间正常计算。
   2）下一个进程的到达时间大于上一个进程的完成时间，则完成时间等于到达时间加运行时间，周转时间等于运行时间。

以下是我的输出结果：

在SJF中的排序算法，if(min_time>pcb[j].run_time&&pcb[j].finished==false&&pcb[j].arrive_time<=pcb[last_finishedPCB_index].finish_time)，这样其实并没有将最后一个进程考虑进去，导致最后一个进程的时间可能会输出为0。

总结：以上便是我对此算法的粗略理解，仅供参考。以后会不断改进以及编辑出更优秀的博客出来！！！