{"id":3226,"date":"2025-06-09T08:36:52","date_gmt":"2025-06-09T08:36:52","guid":{"rendered":"https:\/\/diznr.com\/?p=3226"},"modified":"2025-06-09T08:36:52","modified_gmt":"2025-06-09T08:36:52","slug":"day-02part-06-operating-system-for-gate-shortest-job-first-algorithm-scheduling","status":"publish","type":"post","link":"https:\/\/www.reilsolar.com\/pdf\/day-02part-06-operating-system-for-gate-shortest-job-first-algorithm-scheduling\/","title":{"rendered":"Day 02Part 06- Operating System for Gate – Shortest Job First Scheduling Algorithm"},"content":{"rendered":"

Day 02Part 06- Operating System for Gate – Shortest Job First Scheduling Algorithm<\/p>\n

[fvplayer id=”307″]<\/p>\n

\u00a0Day 02 Part 06 – Operating System for GATE<\/strong><\/h3>\n

Shortest Job First (SJF) Scheduling Algorithm<\/strong><\/h3>\n

\u00a0What is SJF Scheduling?<\/strong><\/h3>\n

Shortest Job First (SJF)<\/strong> is a CPU scheduling algorithm<\/strong> that selects the process with the smallest burst time<\/strong> for execution next.<\/p>\n

It is also known as Shortest Next CPU Burst Scheduling<\/strong>.
There are two types<\/strong> of SJF scheduling:<\/p>\n

    \n
  1. Non-Preemptive SJF<\/strong> – Once a process starts execution, it cannot be interrupted<\/strong>.<\/li>\n
  2. Preemptive SJF (Shortest Remaining Time First – SRTF)<\/strong> – The process can be interrupted<\/strong> if a shorter job arrives.<\/li>\n<\/ol>\n

    \u00a0Characteristics of SJF<\/strong><\/h3>\n

    Optimal<\/strong> in reducing average waiting time<\/strong>
    Best case scenario<\/strong> for batch processing
    Difficult to implement in real-world OS<\/strong> (because burst time is unknown)<\/p>\n

    \u00a0Non-Preemptive SJF Example<\/strong><\/h3>\n

    Let’s consider 4 processes<\/strong> with the following burst times:<\/p>\n\n\n\n\n\n\n\n\n
    Process<\/th>\nArrival Time<\/th>\nBurst Time<\/th>\n<\/tr>\n<\/thead>\n
    P1<\/td>\n0<\/td>\n7<\/td>\n<\/tr>\n
    P2<\/td>\n2<\/td>\n4<\/td>\n<\/tr>\n
    P3<\/td>\n4<\/td>\n1<\/td>\n<\/tr>\n
    P4<\/td>\n5<\/td>\n4<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

    Step-by-Step Execution:<\/strong><\/h4>\n
      \n
    1. At t = 0<\/strong>, P1<\/strong> starts execution (since no other process has arrived).<\/li>\n
    2. At t = 2<\/strong>, P2 arrives<\/strong>, but P1 is still running.<\/li>\n
    3. At t = 4<\/strong>, P3 arrives<\/strong>.<\/li>\n
    4. At t = 7<\/strong>, P3 (Shortest Job: 1) is selected<\/strong>.<\/li>\n
    5. At t = 8<\/strong>, P2 (Shortest Job: 4) is selected<\/strong>.<\/li>\n
    6. At t = 12<\/strong>, P4 (Shortest Job: 4) is selected<\/strong>.<\/li>\n<\/ol>\n

      Gantt Chart:<\/strong><\/h4>\n
      \n
      <\/div>\n
      \n
      <\/div>\n<\/div>\n
      | P1 | P3 | P2 | P4 |
      \n0 7 8 12 16
      \n<\/code><\/div>\n<\/div>\n

      Calculation of Waiting Time & Turnaround Time<\/strong><\/h4>\n

      Waiting\u00a0Time=Turnaround\u00a0Time\u2212Burst\u00a0Time\\text{Waiting Time} = \\text{Turnaround Time} – \\text{Burst Time}<\/span>Waiting\u00a0Time<\/span><\/span>=<\/span><\/span>Turnaround\u00a0Time<\/span><\/span>\u2212<\/span><\/span>Burst\u00a0Time<\/span><\/span><\/span><\/span><\/span><\/span><\/p>\n\n\n\n\n\n\n\n\n
      Process<\/th>\nArrival Time<\/th>\nBurst Time<\/th>\nCompletion Time<\/th>\nTurnaround Time (TAT)<\/th>\nWaiting Time (WT)<\/th>\n<\/tr>\n<\/thead>\n
      P1<\/td>\n0<\/td>\n7<\/td>\n7<\/td>\n7 – 0 = 7<\/td>\n0<\/td>\n<\/tr>\n
      P2<\/td>\n2<\/td>\n4<\/td>\n12<\/td>\n12 – 2 = 10<\/td>\n10 – 4 = 6<\/td>\n<\/tr>\n
      P3<\/td>\n4<\/td>\n1<\/td>\n8<\/td>\n8 – 4 = 4<\/td>\n4 – 1 = 3<\/td>\n<\/tr>\n
      P4<\/td>\n5<\/td>\n4<\/td>\n16<\/td>\n16 – 5 = 11<\/td>\n11 – 4 = 7<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

      Average Waiting Time (AWT) = (0 + 6 + 3 + 7) \/ 4 = 4<\/strong>
      Average Turnaround Time (ATAT) = (7 + 10 + 4 + 11) \/ 4 = 8<\/strong><\/p>\n

      \u00a0Preemptive SJF (SRTF) Example<\/strong><\/h3>\n

      In Shortest Remaining Time First (SRTF)<\/strong>, if a new process with a shorter burst time<\/strong> arrives, the CPU switches to that process immediately<\/strong>.<\/p>\n

      Example:<\/strong> If P1 (10 ms)<\/strong> is running and P2 (3 ms)<\/strong> arrives, P1 is preempted<\/strong>, and P2 executes first.<\/p>\n

      \u00a0Advantages & Disadvantages<\/strong><\/h3>\n

      Pros:<\/strong>
      \u00a0Best for minimizing waiting time
      \u00a0Good for batch processing<\/strong><\/p>\n

      Cons:<\/strong>
      Difficult to implement<\/strong> (since burst time is not known beforehand)
      Starvation issue<\/strong> (Longer processes might never get CPU time)<\/p>\n

      \u00a0Applications of SJF<\/strong><\/h3>\n

      Batch processing systems<\/strong>
      Job scheduling in databases<\/strong>
      Load balancing in cloud computing<\/strong><\/p>\n

      Would you like a Python\/C++ program<\/strong> to implement SJF Scheduling?<\/p>\n

      Day 02Part 06- Operating System for Gate – Shortest Job First Scheduling Algorithm<\/a><\/h3>\n

      Unit IV \u2013 CPU Scheduling and Algorithm<\/a><\/h3>\n

      OPERATING SYSTEM<\/h3>\n

      Here\u2019s a clear and exam-focused explanation of Shortest Job First (SJF) Scheduling Algorithm<\/strong> \u2013 perfect for GATE, B.Tech, or Operating System coursework<\/strong>. This is Day 02 – Part 06<\/strong> of an OS series.<\/p>\n

      \n

      \ud83d\udda5\ufe0f Operating System \u2013 Scheduling Algorithms<\/strong><\/h2>\n

      \ud83d\udcd8 Day 02, Part 06: Shortest Job First (SJF)<\/strong><\/h3>\n
      \n

      \ud83d\udd39 What is SJF (Shortest Job First)?<\/strong><\/h2>\n

      SJF is a CPU scheduling algorithm<\/strong> where the process with the smallest burst time<\/strong> (execution time) is executed first<\/strong>.<\/p>\n

      It is also known as:<\/p>\n