LJF：最长作业优先调度算法

The LJF, which stands for Longest Job Scheduling Algorithm keeps track of the Burst time of all the available processes at the arrival time itself and then assigns the processor to that process which has the longest burst time. It a type of non-preemptive scheduling algorithm where once a process starts its execution, it cannot be interrupted in between its processing and any other process can be executed only after the assigned process has completed its processing and has been terminated.

LJF代表最长作业调度算法 ，它会在到达时间本身跟踪所有可用进程的突发时间，然后将处理器分配给具有最长突发时间的进程。 它是一种非抢占式调度算法，其中，一旦某个进程开始执行，就无法在其处理之间中断它，并且只有在分配的进程完成其处理并终止之后，才能执行任何其他进程。

The LJF scheduling algorithm is just as the SJF. The only difference is that The SJF scheduling algorithm executes the processes with the shortest burst time first, whereas, in LJF, the processes with the longest burst time are executed first. However, LJF is not considered to be an efficient way of process scheduling because there are many drawbacks of it like the Convoy effect is displayed by it, it has very large average turn-around time and average waiting time. This results in slow processing and decreases the effectiveness of the system.

LJF调度算法与SJF一样 。 唯一的区别是SJF调度算法首先执行突发时间最短的进程，而在LJF中 ，首先执行突发时间最长的进程。 但是， LJF不被认为是一种有效的流程调度方式，因为它有很多缺点，例如它显示了Convoy效果，它具有很大的平均周转时间和平均等待时间。 这导致处理缓慢并降低系统的有效性。

Let us explain it with the help of an example to understand it better. Suppose there are four processes with process ID's P1, P2, P3, and P4 and they enter into the CPU as follows:

让我们借助一个示例对其进行解释，以更好地理解它。 假设有四个进程ID为P1 ， P2 ， P3和P4 ，它们按如下方式进入CPU：

So, if the OS follows the FCFS algorithm for scheduling these processes, then they will be executed in the following manner:

因此，如果操作系统遵循FCFS算法来调度这些进程，则将以以下方式执行它们：

Gant Chart:

甘特图：

Explanation: As the processes keep arriving, the one with the largest burst time are executed first. And no process can interrupt in the execution of the other process in between.

说明：随着进程不断到达，将首先执行突发时间最大的进程。 并且没有一个进程可以中断其他进程之间的执行。

    Total Turn Around Time = 2 + 11 + 6 + 8
                = 27 milliseconds
    Average Turn Around Time= Total Turn Around Time / Total No. of Processes
                = 27 / 4
                = 6.75 milliseconds

    Total Waiting Time = 0 + 10 + 0 + 5
                = 15 milliseconds
    Average Waiting Time = Total Waiting Time / Total No. of Processes
                = 15 / 4
                = 3.75 milliseconds

翻译自: https://www.includehelp.com/operating-systems/ljf-longest-job-first-scheduling-algorithm.aspx