kagenzaclaudiengmailcom • 2020-10-13 13:55:52

FIRST OF ALL LETS GET TO KNOW WHAT IS CPU SCHEDULING

CPU SCHEDULING a process of determining which process will own CPU for execution while another process is on hold. The main task of CPU scheduling is to make sure that whenever the CPU remains idle, the OS at least select one of the processes available in the ready queue for execution. The selection process will be carried out by the CPU scheduler. It selects one of the processes in memory that are ready for execution.
<h4 id="5308" class="cp cq cr cs b ct cu cv cw cx cy cz da db dc dd de df dg dh di dj"><strong>CPU Scheduling Algorithms</strong></h4>
<p id="412e" class="fh fi cr fj b fk fl fm fn fo fp fq fr fs ft fu fv fw fx fy fz ga gb gc gd ge cj dj" data-selectable-paragraph="">The CPU, like every part of the computer has a task to perform, as well as a set of instructions on how to perform such tasks. Since a numerous amount of programs can be in memory at the same time, the CPU needs a sequence of functionality; that’s where the process manager comes in. The Process manager handles the removal of the running process from the CPU and the selection of another process.</p>
<p id="5746" class="fh fi cr fj b fk fl fm fn fo fp fq fr fs ft fu fv fw fx fy fz ga gb gc gd ge cj dj" data-selectable-paragraph="">The OS maintains all Process in scheduling Queues. It maintains a separate queue for each of the process states and when the state of a process is changed, it is unlinked from its current queue and moved to its new state queue.</p>
<p class="fh fi cr fj b fk fl fm fn fo fp fq fr fs ft fu fv fw fx fy fz ga gb gc gd ge cj dj" data-selectable-paragraph=""><img src="https://miro.medium.com/max/491/1*B8DCskub0VXdf3liNq6Uxg.jpeg" alt="Image for post" /></p>

<ul class="">
<li id="4181" class="fh fi cr fj b fk fl fm fn fo fp fq fr fs ft fu fv fw fx fy fz ga gb gc gd ge gz ha hb dj" data-selectable-paragraph=""><strong class="fj hc">Job queue</strong> − This queue keeps all the processes in the system.</li>
<li id="ae4c" class="fh fi cr fj b fk hd fm fn fo he fq fr fs hf fu fv fw hg fy fz ga hh gc gd ge gz ha hb dj" data-selectable-paragraph=""><strong class="fj hc">Ready queue</strong> − This queue keeps a set of all processes that are in memory, and are waiting to be executed</li>
<li id="fab5" class="fh fi cr fj b fk hd fm fn fo he fq fr fs hf fu fv fw hg fy fz ga hh gc gd ge gz ha hb dj" data-selectable-paragraph=""><strong class="fj hc">Device queues</strong> − The processes which are blocked due to unavailability of an I/O device constitute this queue.</li>
</ul>
<p id="31af" class="fh fi cr fj b fk fl fm fn fo fp fq fr fs ft fu fv fw fx fy fz ga gb gc gd ge cj dj" data-selectable-paragraph="">The OS can use different scheduling algorithms to manage each queue. The process manager determines how to move processes between the ready and run queues which can only have one entry per processor core on the system.</p>
<p id="c9a0" class="fh fi cr fj b fk fl fm fn fo fp fq fr fs ft fu fv fw fx fy fz ga gb gc gd ge cj dj" data-selectable-paragraph="">There are six popular methods of scheduling processes to the CPU, which are:</p>

<ul class="">
<li id="2ac5" class="fh fi cr fj b fk fl fm fn fo fp fq fr fs ft fu fv fw fx fy fz ga gb gc gd ge gz ha hb dj" data-selectable-paragraph="">First Come, First Serve</li>
<li id="fd75" class="fh fi cr fj b fk hd fm fn fo he fq fr fs hf fu fv fw hg fy fz ga hh gc gd ge gz ha hb dj" data-selectable-paragraph="">Shortest Job First</li>
<li id="0083" class="fh fi cr fj b fk hd fm fn fo he fq fr fs hf fu fv fw hg fy fz ga hh gc gd ge gz ha hb dj" data-selectable-paragraph="">Priority Scheduling</li>
<li id="f9c6" class="fh fi cr fj b fk hd fm fn fo he fq fr fs hf fu fv fw hg fy fz ga hh gc gd ge gz ha hb dj" data-selectable-paragraph="">Shortest Remaining Time</li>
<li id="0046" class="fh fi cr fj b fk hd fm fn fo he fq fr fs hf fu fv fw hg fy fz ga hh gc gd ge gz ha hb dj" data-selectable-paragraph="">Round Robin(RR)</li>
<li id="5862" class="fh fi cr fj b fk hd fm fn fo he fq fr fs hf fu fv fw hg fy fz ga hh gc gd ge gz ha hb dj" data-selectable-paragraph="">Multiple-Level Queues</li>
</ul>
<p id="31b4" class="fh fi cr fj b fk fl fm fn fo fp fq fr fs ft fu fv fw fx fy fz ga gb gc gd ge cj dj" data-selectable-paragraph="">These algorithms can be either non-preemptive or preemptive. Non-preemptive algorithms are made so that once a process has a the resource, it does not have to let go of the resource until its given time if over. In the other hand, the preemptive scheduling functions with priority, which means the schedule can stop the process from using the resource to give it to another process with a higher priority.</p>
<p id="ae74" class="fh fi cr fj b fk fl fm fn fo fp fq fr fs ft fu fv fw fx fy fz ga gb gc gd ge cj dj" data-selectable-paragraph=""><strong class="fj hc">First In, First Out:</strong></p>

<figure class="gg gh gi gj gk gl cb cc paragraph-image">
<div class="cb cc hi">
<div class="gr s gs gt">
<div class="hj gv s">
<div class="gm gn t u v go aj dv gp gq"><img class="t u v go aj gw gx at ss" src="https://miro.medium.com/max/60/1*tAf9CrfiH0IYUCKBMgNASw.jpeg?q=20" alt="Image for post" width="484" height="293" /></div>
<img class="sn so t u v go aj c" src="https://miro.medium.com/max/484/1*tAf9CrfiH0IYUCKBMgNASw.jpeg" sizes="484px" srcset="https://miro.medium.com/max/276/1*tAf9CrfiH0IYUCKBMgNASw.jpeg 276w, https://miro.medium.com/max/484/1*tAf9CrfiH0IYUCKBMgNASw.jpeg 484w" alt="Image for post" width="484" height="293" /></div>
</div>
</div></figure>
<p id="1997" class="fh fi cr fj b fk fl fm fn fo fp fq fr fs ft fu fv fw fx fy fz ga gb gc gd ge cj dj" data-selectable-paragraph="">First come first serve, is just as it sounds like. The task that comes first, gets executed first. It is also a non-preemptive algorithm. While this method ensures that each process has a fair amount of time to be executed, it usually has poor performance due to high average waiting time.</p>
<p id="b415" class="fh fi cr fj b fk fl fm fn fo fp fq fr fs ft fu fv fw fx fy fz ga gb gc gd ge cj dj" data-selectable-paragraph=""><strong class="fj hc">Shortest Job First:</strong></p>

<figure class="gg gh gi gj gk gl cb cc paragraph-image">
<div class="cb cc hk">
<div class="gr s gs gt">
<div class="hl gv s">
<div class="gm gn t u v go aj dv gp gq"><img class="t u v go aj gw gx at ss" src="https://miro.medium.com/max/60/1*L_V1OgsQEPFMwSxcMy1Kxg.jpeg?q=20" alt="Image for post" width="485" height="299" /></div>
<img class="sn so t u v go aj c" src="https://miro.medium.com/max/485/1*L_V1OgsQEPFMwSxcMy1Kxg.jpeg" sizes="485px" srcset="https://miro.medium.com/max/276/1*L_V1OgsQEPFMwSxcMy1Kxg.jpeg 276w, https://miro.medium.com/max/485/1*L_V1OgsQEPFMwSxcMy1Kxg.jpeg 485w" alt="Image for post" width="485" height="299" /></div>
</div>
</div></figure>
<p id="f556" class="fh fi cr fj b fk fl fm fn fo fp fq fr fs ft fu fv fw fx fy fz ga gb gc gd ge cj dj" data-selectable-paragraph="">Shortest Job First is a preemptive algorithm that executes the shortest job first. This algorithm has one of the best approach to minimize the waiting time, when the processor knows in advance how much time it will take to execute each process. In an interactive OS this algorithms fails, since small process will get to cut the line each time they arrive which could lead to starvation of the longer tasks.</p>
<p id="5b06" class="fh fi cr fj b fk fl fm fn fo fp fq fr fs ft fu fv fw fx fy fz ga gb gc gd ge cj dj" data-selectable-paragraph=""><strong class="fj hc">Priority Scheduling</strong></p>

<figure class="gg gh gi gj gk gl cb cc paragraph-image">
<div class="cb cc hi">
<div class="gr s gs gt">
<div class="hj gv s">
<div class="gm gn t u v go aj dv gp gq"><img class="t u v go aj gw gx at ss" src="https://miro.medium.com/max/60/1*NiH---sfzSelEKZOjGf40g.jpeg?q=20" alt="Image for post" width="484" height="293" /></div>
<img class="sn so t u v go aj c" src="https://miro.medium.com/max/484/1*NiH---sfzSelEKZOjGf40g.jpeg" sizes="484px" srcset="https://miro.medium.com/max/276/1*NiH---sfzSelEKZOjGf40g.jpeg 276w, https://miro.medium.com/max/484/1*NiH---sfzSelEKZOjGf40g.jpeg 484w" alt="Image for post" width="484" height="293" /></div>
</div>
</div></figure>
<p id="a5e4" class="fh fi cr fj b fk fl fm fn fo fp fq fr fs ft fu fv fw fx fy fz ga gb gc gd ge cj dj" data-selectable-paragraph="">Priority Scheduling is a non-preemptive algorithm that assigns each task a priority number to be executed by. If two task arrive at the same time, they would be dealt in a first come first serve manner. Priority can be decided on a number of factors such as memory requirements, time requirements or any other resource requirement.</p>
<p id="28f0" class="fh fi cr fj b fk fl fm fn fo fp fq fr fs ft fu fv fw fx fy fz ga gb gc gd ge cj dj" data-selectable-paragraph=""><strong class="fj hc">Shortest Remaining Time:</strong></p>
<p id="52d0" class="fh fi cr fj b fk fl fm fn fo fp fq fr fs ft fu fv fw fx fy fz ga gb gc gd ge cj dj" data-selectable-paragraph="">Shortest Remaining Time is very similar to Short Job First. Unlike SJF, this algorithm looks at how much time is left in the execution time of the task in order to give it CPU time. This algorithm is also preemptive.</p>
<p id="d87e" class="fh fi cr fj b fk fl fm fn fo fp fq fr fs ft fu fv fw fx fy fz ga gb gc gd ge cj dj" data-selectable-paragraph=""><strong class="fj hc">Round Robin</strong></p>

<figure class="gg gh gi gj gk gl cb cc paragraph-image">
<div class="cb cc hm">
<div class="gr s gs gt">
<div class="hn gv s">
<div class="gm gn t u v go aj dv gp gq"><img class="t u v go aj gw gx at ss" src="https://miro.medium.com/max/60/1*5mxGaDvwu_61bhrKIhvglw.jpeg?q=20" alt="Image for post" width="638" height="479" /></div>
<img class="sn so t u v go aj c" src="https://miro.medium.com/max/638/1*5mxGaDvwu_61bhrKIhvglw.jpeg" sizes="638px" srcset="https://miro.medium.com/max/276/1*5mxGaDvwu_61bhrKIhvglw.jpeg 276w, https://miro.medium.com/max/552/1*5mxGaDvwu_61bhrKIhvglw.jpeg 552w, https://miro.medium.com/max/638/1*5mxGaDvwu_61bhrKIhvglw.jpeg 638w" alt="Image for post" width="638" height="479" /></div>
</div>
</div></figure>
<p id="4820" class="fh fi cr fj b fk fl fm fn fo fp fq fr fs ft fu fv fw fx fy fz ga gb gc gd ge cj dj" data-selectable-paragraph="">Round Robin is a preemptive algorithm, which works by using a quantum time. Each task is only allowed to run for this quantum time, The task manager then preempts the resource and gives it to the next task. It repeats this process until all task are finish.</p>
<p id="2ae7" class="fh fi cr fj b fk fl fm fn fo fp fq fr fs ft fu fv fw fx fy fz ga gb gc gd ge cj dj" data-selectable-paragraph=""><strong class="fj hc">Multiple-Level Queues</strong></p>
<p id="9efc" class="fh fi cr fj b fk fl fm fn fo fp fq fr fs ft fu fv fw fx fy fz ga gb gc gd ge cj dj" data-selectable-paragraph="">Multiple-level queues are used when tasks can places into groups depending on their characteristics, such as CPU time or Memory size. Each queue is assign a priority to be executed, and are allowed to have its own scheduling algorithm.</p>
<p id="19a6" class="fh fi cr fj b fk fl fm fn fo fp fq fr fs ft fu fv fw fx fy fz ga gb gc gd ge cj dj" data-selectable-paragraph="">For example, CPU-bound jobs can be scheduled in one queue and all I/O-bound jobs in another queue. The Process Scheduler then alternately selects jobs from each queue and assigns them to the CPU based on the algorithm assigned to the queue.</p> PostVer 0

1403861656qqcom • 2020-10-13 14:26:48

PostVer 0

1403861656qqcom • 2020-10-13 14:36:22

CPU scheduling algorithm

1.FCFS (First come, first served)

There is no guarantee of turnaround time,

2.SJF (Short jobs preferred)

This method has the minimum turnaround time.

However, if one of the intermediate tasks is to be executed now, it must wait until the previous task is completed, and the response time cannot be guaranteed.

3. Time slice wheel scheduling,

Each task is divided into several time slices, and the response time is guaranteed.

4. Priority scheduling

A high-priority process, always executed, can produce hunger. PostVer 0

2031115154qqcom • 2020-10-13 15:03:53

FCFS：simple algorithm, easily realize, but if there is a short burst time process in the ready queue when the CPU is serving for a long burst time process, this short burst time process have to wait until the long burst time process finish, so, the average waiting time would be probably long.

SFJ: It can be divided into 2 ways, non-preemptive and preemptive. SFJ have better performance in average waiting time and average turnaround time than FCFS, especially the preemptive SFJ. People need to care about the change in the ready queue when using the preemptive SFJ. Moreover, the preemptive SFJ algorithm may result in starvation because of many short burst time processes coming continually.

Priority: Also have non-preemptive way and preemptive way, and when using the preemptive way, it’s necessary to care about the new arrived process in the ready queue, once there is a new arrived process with higher priority than the serving process, the serving one would be taken over by the new one. And the preemptive-Priority maybe result in starvation.

Round Robin(RR): better respond and ensure that every process in the ready queue would be chosen to run. But if the quantum is large, it’s performance may be more terrible than FSFC algorithm.

Multi-level queue: the general improvement and combination of the RR and FCFS. PostVer 0

997371991qqcom • 2020-10-13 15:12:34

1 first come first served scheduling
When the FCFS process enters the end of the queue, it is allocated to the first CPU queue. The running process is then removed from the queue.
The average waiting time of FCFS strategy is quite long.
2 shortest job priority scheduling
SJF（shortest-job-first）
The real difficulty of the SJF algorithm is how to know the length of the next CPU request. SJF scheduling is often used for long-term scheduling.

3 priority scheduling
Each process has a priority associated with it, and the process with the highest priority is assigned to the CPU. Processes with the same priority are scheduled in FCFS order.

Priority can be defined internally or externally.

Priority scheduling can be preemptive or non preemptive.

One of the main problems of priority scheduling algorithm is infinite blocking. The solution is aging, which is a technique to gradually increase the priority of processes waiting in the system for a long time.

4-round scheduling
The round robin (RR) scheduling algorithm is specially designed for time-sharing systems. Define a small time unit, called a time quantity or time slice. The time slice is usually 10 ms to 100 ms. The ready queue is processed as a circular queue. The CPU scheduler loop requires a queue to allocate no more than one time slice interval to each process.

If the context switching time is about 10% of the time slice, about 10% of the CPU time will be wasted on context switching.
Multi level queue 5
（multilevel queue-scheduling algorithm）
Different queues can be used for foreground and background processes. The foreground queue may be scheduled by RR algorithm, while the background queue may be scheduled by FCFS algorithm.

Multi level feedback queue scheduling
For multi-level queue scheduling algorithm, usually when a process enters the system, it is permanently assigned to a queue, and the process does not move between queues. PostVer 0

962305148qqcom • 2020-10-13 15:12:50

1.First Come, First Served(FCFS)

It is a first come, first serve scheduling algorithm, which task comes first, it will serve for which task first.

2.SJF(Short Job First)

That is, the task whose service time is short should be scheduled first.

The scheduling algorithm based on time slice rotation is to set A time slice, such as 10 CPU time, and then constantly switch in four processes A, B, C and D. Each process executes at 10, and when the time is up, switch to the next process executes at 10 until all executions are completed. PostVer 0

1756894282qqcom • 2020-10-13 15:22:11

<p class="p1"><span class="s1">FCFS</span></p>
<p class="p3"><span class="s2">According to the sequence of processes entering the ready state queue, when the running state process enters the waiting or ending state, the next process in the ready queue will occupy the CPU for execution. Here is an example of first come, first served, the processing time of the three processes They are 12, 3, and 3 respectively, and they are discussed in the order of arrival of two processes (they arrive at the same time, but there is also a sequence)</span></p>
<p class="p3"><span class="s2">SPN</span></p>
<p class="p3"><span class="s2">Select the process with the shortest execution time in the ready queue to take up the CPU to enter the running state, and the ready queue is sorted according to the expected execution time (the accurate cloud running time of the process ends before execution and is unknowable. The approximate running time can only be obtained by pre-judgment , Then sort)</span></p>
<p class="p3"><span class="s2">RR</span></p>
<p class="p3"><span class="s2">The concept of time slice: the basic time unit allocated to CPU or processor resources, when the time slice ends, switch to the next ready process execution according to the FCFS algorithm</span></p> PostVer 0

yeqirunoutlookcom • 2020-10-13 15:23:31

1. First come first served scheduling algorithm (FCFS)

The service is based on the arrival time of the ready queue. At this time, the ready queue is a FIFO queue. The first come first serve thread, and the last arriving thread cannot preempt the previous serving thread. The advantage of this algorithm is that it is easy to implement, and the disadvantage is obvious. When the CPU process interval changes greatly, the average waiting time will change greatly.

2. Shortest job first scheduling (SJF)

As the name implies, the CPU process interval with the shortest execution first. If two process intervals have the same length, they are scheduled according to FCFS.

SJF can be preemptive or non preemptive. Its average waiting time is better than that of FCFS.

3. Priority scheduling

In fact, the SJF algorithm above is a special priority scheduling, but the definition of priority here is more extensive. The priority of SJF algorithm is defined according to the length of CPU process interval, and the priority here can be some other definitions.

Priority scheduling can be preemptive or non preemptive.

One of the main problems of priority scheduling is infinite blocking (also known as starvation). If a thread has a low priority, it may take a long time for the thread to execute, or even never execute. One solution is aging (increase the priority of the thread as time goes on)

4. Rotation scheduling (RR)

Rotation scheduling is designed specifically for time-sharing systems. It is similar to FCFS, but adds preemption to switch threads. Define a small time unit, called time slice, which is usually 10-100ms. In order to implement RR algorithm, the ready queue is saved as FIFO queue, and the new process is added to the end of the ready queue. The CPU scheduler selects the first process from the ready queue, sets the timer to interrupt after a time slice, and then dispatches the process.

If the CPU interval of the process is less than the time slice, the process itself will release the CPU, and the scheduler will continue to process the next process. If the CPU interval of the current process is longer than the time slice, the timer will generate CPU interrupt and implement context switch. Then, the process will be put at the end of the ready queue to continue scheduling the first process in the ready queue.

5. Multi level queue scheduling:

Here, processes are grouped, FCFS and SJF algorithms are used in the group, and priority scheduling or rotation scheduling is implemented between groups. However, processes are not allowed to switch between groups.

6. Multi level feedback queue scheduling

To allow processes to switch between groups, the main idea is to distinguish processes according to the characteristics of different intervals. If the CPU process takes up too much CPU time, it will be transferred to the lower priority queue. This form of aging prevents hunger. PostVer 0

yeqirunoutlookcom • 2020-10-13 15:23:31

1. First come first served scheduling algorithm (FCFS)

The service is based on the arrival time of the ready queue. At this time, the ready queue is a FIFO queue. The first come first serve thread, and the last arriving thread cannot preempt the previous serving thread. The advantage of this algorithm is that it is easy to implement, and the disadvantage is obvious. When the CPU process interval changes greatly, the average waiting time will change greatly.

2. Shortest job first scheduling (SJF)

As the name implies, the CPU process interval with the shortest execution first. If two process intervals have the same length, they are scheduled according to FCFS.

SJF can be preemptive or non preemptive. Its average waiting time is better than that of FCFS.

3. Priority scheduling

In fact, the SJF algorithm above is a special priority scheduling, but the definition of priority here is more extensive. The priority of SJF algorithm is defined according to the length of CPU process interval, and the priority here can be some other definitions.

Priority scheduling can be preemptive or non preemptive.

One of the main problems of priority scheduling is infinite blocking (also known as starvation). If a thread has a low priority, it may take a long time for the thread to execute, or even never execute. One solution is aging (increase the priority of the thread as time goes on)

4. Rotation scheduling (RR)

Rotation scheduling is designed specifically for time-sharing systems. It is similar to FCFS, but adds preemption to switch threads. Define a small time unit, called time slice, which is usually 10-100ms. In order to implement RR algorithm, the ready queue is saved as FIFO queue, and the new process is added to the end of the ready queue. The CPU scheduler selects the first process from the ready queue, sets the timer to interrupt after a time slice, and then dispatches the process.

If the CPU interval of the process is less than the time slice, the process itself will release the CPU, and the scheduler will continue to process the next process. If the CPU interval of the current process is longer than the time slice, the timer will generate CPU interrupt and implement context switch. Then, the process will be put at the end of the ready queue to continue scheduling the first process in the ready queue.

5. Multi level queue scheduling:

Here, processes are grouped, FCFS and SJF algorithms are used in the group, and priority scheduling or rotation scheduling is implemented between groups. However, processes are not allowed to switch between groups.

6. Multi level feedback queue scheduling

To allow processes to switch between groups, the main idea is to distinguish processes according to the characteristics of different intervals. If the CPU process takes up too much CPU time, it will be transferred to the lower priority queue. This form of aging prevents hunger. PostVer 0

804824950qqcom • 2020-10-13 15:30:26

FCFS policies can be easily implemented through FIFO queues. When a process enters the ready queue, its PCB is linked to the end of the queue. When the CPU is idle, it is allocated to the process at the head of the queue, and the running process is removed from the queue. FCFS scheduling code is simple to write and easy to understand.

The disadvantage of THE FCFS strategy is that the average wait time tends to be long.

SJF:
Advantages:
Improve average turnaround time and average weighted turnaround time compared with FCFS, and shorten the waiting time of operation;
Improve system throughput;
Disadvantages:
Very bad for long operations and may not be implemented for a long time;
Failure to prioritize implementation according to the urgency of the operation;
It is difficult to accurately estimate the execution time of a job (process), thus affecting scheduling performance. PostVer 0

1285795916qqcom • 2020-10-13 15:39:29

邱锐鹏2018329621199

(1) First-Come, First-Served Scheduling
FCFS is the simpliest CPU-scheduling algorithm. With this scheme, the process that requests the CPU first is allocated the CPU first.
(2) Shortest-Job-First Scheduling
When the CPU is available, it is assigned to the process that has the smallest next CPU burst. If the next CPU bursts of two processes are the same, FCFS scheduling is used to break the tie.
(3) Priority Scheduling
A priority is associated with each process, and the CPU is allocated to the process with the highest priority. Equal-priority processes are scheduled in FCFS order.
(4) Round-Robin Scheduling
The RR scheduling algorithm is designed especially for time-sharing aystems. It is similar to FCFS scheduling, but the preemption is added to switch between processes. A small unit of time, called a time quantum or time slice, is defined.
(5) Multilevel Queue Scheduling
A multilevel queue scheduling algorithm partitions the ready queue into several seperate queues. The processes are permanently assigned to one queue, generally based on some property of the process. Each queue has its own scheduling algorithm. In addition, there must be scheduling among the queues.
(6)Multilevel Feedback-Queue Scheduling
The MFQS allows a process to move between queues. The idea is to seperate processes according to the characteristics of their CPU burst. If a process uses too much CPU time, it will be moved to a lower-priority queue. PostVer 0

653968106qqcom • 2020-10-13 20:37:49

2018329621008徐天然

1.FCFS（first-come,first-served）
When a process enters the on-demand queue, its PCB is linked to the end of the queue. When the CPU is idle, the CPU is allocated to the process at the head of the queue. The running process is then removed from the queue.
The average waiting time of FCFS strategy is quite long
FCFS scheduling algorithm is non preemptive.

2.SJF（shortest-job-first）
As the name implies, the shortest CPU process interval is executed first. If two process intervals have the same length, it is scheduled according to FCFS.
How to know the length of the next CPU request when the SJF algorithm is really difficult. SJF scheduling is often used for long-term scheduling.

3.Priority Scheduling in Fact
Each process has a priority associated with it, and the process with the highest priority is assigned to the CPU. Processes with the same priority are scheduled in FCFS order.
Priority can be defined internally or externally.
Priority scheduling can be preemptive or non preemptive.
One of the main problems of priority scheduling algorithm is infinite blocking. The solution is aging, which is a technique to gradually increase the priority of processes waiting in the system for a long time.

4.RR(Round Robin)
The round robin (RR) scheduling algorithm is specially designed for time-sharing systems. Define a small time unit, called a time quantity or time slice. The time slice is usually 10 ms to 100 ms. The ready queue is processed as a circular queue. The CPU scheduler loop requires a queue to allocate no more than one time slice interval to each process.
If the context switching time is about 10% of the time slice, about 10% of the CPU time will be wasted on context switching.

5.Multilevel Queue-Scheduling Algorithm
Different queues can be used for foreground and background processes. The foreground queue may be scheduled by RR algorithm, while the background queue may be scheduled by FCFS algorithm.

6.Multi Level Feedback Queue Scheduling
For multi-level queue scheduling algorithm, usually when a process enters the system, it is permanently assigned to a queue, and the process does not move between queues. PostVer 0

1119833189qqcom • 2020-10-13 23:47:54

Various CPU scheduling algorithms1.First Come, First Served(FCFS)It is a first come, first serve scheduling algorithm, which task comes first, it will serve for which task first. Because in a system, short tasks may account for a large proportion, those later entered short tasks, have to wait for the completion of a large number of tasks before the CPU service for these short tasks, in this way, many short tasks even though the service time is short, but their turnaround time is relatively long. We can try to bring short tasks forward, short tasks forward, reducing the average turnaround time of short-task-oriented systems, thus we have short-job-first CPU scheduling algorithms.2.SJF(Short Job First)That is, the task whose service time is short should be scheduled first.3.RR algorithm (rotation scheduling according to time slice) PostVer 0

1720650158qqcom • 2020-10-14 11:18:17

FCFS: In job scheduling, the algorithm selects one or more jobs from the standby job queue at a time, brings them into memory, allocates the necessary resources, creates processes and puts them into the ready queue.

In process scheduling, the FCFS scheduling algorithm selects the first process to enter the queue from the ready queue each time, assigns the processor to it, puts it into operation, and does not release the processor until it is completed or blocks for some reason.

The short Job First (SJF) scheduling algorithm selects one or more jobs from the backup queue that are estimated to have the shortest running time and brings them into memory for running.

The short process Priority (SPF) scheduling algorithm selects a process with the shortest estimated running time from the ready queue, assigns the processor to it, makes it execute immediately, and does not release the processor until it is completed or some event occurs and blocks.

Priority scheduling algorithm: priority scheduling algorithm is also called priority scheduling algorithm, which can be used for job scheduling and process scheduling.

Multilevel feedback queue scheduling algorithm: Synthesis and development of time slice scheduling algorithm and priority scheduling algorithm. PostVer 0

1730854984qqcom • 2020-10-14 22:51:42

<ol>
<li>First-Come, First-Served Scheduling</li>
</ol>
By far the simplest CPU-scheduling algorithm is the first-come first-serve(FCFS) scheduling algorithm. With this scheme, the process that requests the CPU first is allocated the CPU first. The implementation of the FCFS policy is easily managed with a FIFO queue. When a process enters the ready queue, its PCB is linked onto the tail of the queue. When the CPU is free, it is allocated to the process at the head of the queue. The running process is then removed from the queue. The code for FCFS scheduling is simple to write and understand.
<ol start="2">
<li>Short-Job-First Scheduling</li>
</ol>
A different approach to CPU scheduling is the shortest-job-firs (SJF) scheduling algorithm. This algorithm associates with each process the length of the process’s next CPU burst. When the CPU is available, it is assigned to the process that has the smallest next CPU burst. If the next CPU bursts of two processes are the same, FCFS scheduling is used to break the tie. Note that a more appropriate term for this scheduling method would be the shortest-next-CPU-burst algorithm, because scheduling depends on the length of the next CPU burst of a process, rather than its total length.
<ol start="3">
<li>Round-Robin Scheduling</li>
</ol>
The round-robin (RR) scheduling algorithm is similar to FCFS scheduling, but preemption is added to enable the system to switch between processes. A small unit of time, called a time quantum or time slice, is defined. A time quantum is generally from 10 to 100 milliseconds in length. The ready queue is treated as a circular queue. The CPU scheduler goes around the ready queue, allocating the CPU to each process for a time interval of up to 1 time quantum.
<ol start="4">
<li>Priority Scheduling</li>
</ol>
The SJF algorithm is a special case of the general priority-scheduling algorithm. A priority is associated with each process, and the CPU is allocated to the process with the highest priority. Equal-priority processes are scheduled in FCFS order. An SJF algorithm is simply a priority algorithm where the priority (p) is the inverse of the (predicted) next CPU burst. The larger the CPU burst, the lower the priority, and vice versa.
<ol start="5">
<li>Multilevel Queue Scheduling</li>
</ol>
A multilevel queue scheduling algorithm can also be used to partition processes into several separate queues based on the process type. For example, a common division is made between foreground (interactive) processes and background (batch) processes. These two types of processes have different response-time requirements and so may have different scheduling needs.
<ol start="6">
<li>Multilevel Feedback Queue Scheduling</li>
</ol>
The multilevel feedback queue scheduling algorithm, in contrast, allows a process to move between queues. The idea is to separate processes according to the characteristics of their CPU bursts. If a process uses too much CPU time, it will be moved to a lower-priority queue. PostVer 0

454234624qqcom • 2020-10-15 11:13:45

<ol>
<li><strong> First-Come, First-Served Scheduling</strong></li>
</ol>
By far the simplest CPU-scheduling algorithm is the first-come, first-served (FCFS) scheduling algorithm. With this scheme, the process that requests the CPU first is allocated the CPU first. The implementation of the FCFS policy is easily managed with a FIFO queue. When a process enters the ready queue, its PCB is linked onto the tail of the queue. When the CPU is free, it is allocated to the process at the head of the queue. The running process is then removed from the queue. The code for FCFS scheduling is simple to write and understand. The average waiting time under the FCFS policy, however, Is often quite long.
<ol start="2">
<li><strong> Shortest-Job-First Scheduling</strong></li>
</ol>
This algorithm associates with each process the length of the process’s next CPU burst. When the CPU is available, it is assigned to the process that has the smallest next CPU burst. If the next CPU burst of two processes are the same, FCFS scheduling is used to break the tie.
<ol start="3">
<li><strong> Priority Scheduling</strong></li>
</ol>
The SJF algorithm is a special case of the general priority scheduling algorithm. A priority is associated with each process, and the CPU is allocated to the process with the highest priority. Equal-priority processes are scheduled in FCFS order. Note that we discuss scheduling in terms of high priority and low priority. Priorities are generally indicated by some fixed range of numbers, such as 0 to 7 or 0 to 4,095.
<ol start="4">
<li><strong> Round-Robin Scheduling</strong></li>
</ol>
The round-robin(RR) scheduling algorithm is designed especially for time-sharing systems. It is similar to FCFS scheduling, but preemption is added to switch between processes. A small unit of time, called a time quantum or time slice, is defined. The ready queue is treated as a circular queue. The CPU scheduler goes around the ready queue, allocating the CPU to each process for a time interval of up to 1 time quantum. To implement RR scheduling, we keep the ready queue as a FIFO queue of processes. New processes are added to the tail of the ready queue. The CPU scheduler picks the first processes from the ready queue, sets a timer to interrupt after 1 time quantum, and dispatches the process.
<ol start="5">
<li><strong> Multilevel Queue Scheduling</strong></li>
</ol>
This algorithm has been created for situations in which processes are easily classified into different groups. For example, a common division is made between foreground (interactive) processes and background (batch) processes. These two types of processes have different response-time requirements and so may have different scheduling needs.

A multilevel queue scheduling algorithm partitions the ready queue into several separate queues. The processes are permanently assigned to one queue, generally based on some property of the process, such as memory size, process priority, or process type. Each queue has its own scheduling algorithm.
<ol start="6">
<li><strong> Multilevel Feedback-Queue Scheduling</strong></li>
</ol>
It allows a process to move between queues. The idea is to separate processes according to the characteristics of their CPU bursts. If a process uses too much CPU time, it will be moved to a lower-priority queue. This scheme leaves I/O-bound and interactive processes in the higher-priority queues. In addition, a process that waits too long in a lower-priority queue may be moved to a higher-priority queue. This form of aging prevents starvation. PostVer 0

439731491qqcom • 2020-10-17 17:34:21

<p style="text-align: left;"><a href="http://www.yvsou.com/wp-content/uploads/sites/30/2020/10/01.png"><img class="size-medium wp-image-8656" src="http://www.yvsou.com/wp-content/uploads/sites/30/2020/10/01-300x193.png" alt="" width="300" height="193" /></a></p>
<p style="text-align: left;"><a href="http://www.yvsou.com/wp-content/uploads/sites/30/2020/10/02.png"><img class="size-medium wp-image-8657" src="http://www.yvsou.com/wp-content/uploads/sites/30/2020/10/02-300x263.png" alt="" width="300" height="263" /></a></p>
<p style="text-align: left;"><a href="http://www.yvsou.com/wp-content/uploads/sites/30/2020/10/03.png"><img class="size-medium wp-image-8658" src="http://www.yvsou.com/wp-content/uploads/sites/30/2020/10/03-300x161.png" alt="" width="300" height="161" /></a></p> PostVer 0

244766935qqcom • 2020-10-18 12:20:08

PostVer 0

244766935qqcom • 2020-10-18 12:20:22

First-Come, First-Served Scheduling
By far the simplest CPU -scheduling algorithm is the first-come first-serve
( FCFS ) scheduling algorithm. With this scheme, the process that requests the
CPU first is allocated the CPU first. The implementation of the FCFS policy is
easily managed with a FIFO queue. When a process enters the ready queue, its
PCB is linked onto the tail of the queue. When the CPU is free, it is allocated to
The process at the head of the queue.The running process is then removed from
the queue. The code for FCFS scheduling is simple to write and understand.
Shortest-Job-First Scheduling
A different approach to CPU scheduling is the shortest-job-firs ( SJF ) schedul-
ing algorithm. This algorithm associates with each process the length of the
process’s next CPU burst. Whenthe CPU is available, it is assigned to the process
that has the smallest next CPU burst. If the next CPU bursts of two processes are
the same, FCFS scheduling is used to break the tie. Note that a more appropriate term for this scheduling method would be the shortest-next- CPU -burst
algorithm, because scheduling depends on the length of the next CPU burst of
a process, rather than its total length. We use the term SJF because most people
and textbooks use this term to refer to this type of scheduling.
Round-Robin Scheduling
The round-robin ( RR ) scheduling algorithm is similar to FCFS scheduling, but
Preemption is added to enable the system to switch between processes. A small
unit of time, called a time quantum or time slice, is defined. A time quantum
is generally from 10to100millisecondsinlength.Thereadyqueueistreatedas
a circular queue. The CPU scheduler goes around the ready queue, allocating
the CPU to each process for a time interval of up to 1 time quantum.
Priority Scheduling
The SJF algorithmisaspecialcaseofthegeneralpriority-schedulingalgorithm.
A priority is associated with each process, and the CPU is allocated to the
process with the highest priority. Equal-priority processes are scheduled in
FCFS order. An SJF algorithm is simply a priority algorithm where the priority
(p) is the inverse of the (predicted) next CPU burst. The larger the CPU burst,
the lower the priority, and vice versa.
Multilevel Queue Scheduling
With both priority and round-robin scheduling, all processes may be placed
in a single queue, and the scheduler then selects the process with the highest
priority to run. Depending on how the queues are managed, an O(n) search
may be necessary to determine the highest-priority process. In practice, it is
often easier to have separate queues for each distinct priority, and priority
scheduling simply schedules the process in the highest-priority queue. This
is illustrated in Figure 5.7. This approach—known as multilevel queue—
also works well when priority scheduling is combined with round-robin: if
there are multiple processes in the highest-priority queue, they are executed in
round-robin order. In the most generalized form of this approach, a priority is
assigned statically to each process, and a process remains in the same queue
for the duration of its runtime.
PostVer 0

2470994471qqcom • 2020-10-18 13:35:34

<a href="http://www.yvsou.com/wp-content/uploads/sites/30/2020/10/屏幕截图-2020-10-18-143600.png"><img class="alignnone size-medium wp-image-8663" src="http://www.yvsou.com/wp-content/uploads/sites/30/2020/10/屏幕截图-2020-10-18-143600-300x147.png" alt="" width="300" height="147" /></a> PostVer 0

450766287qqcom • 2020-10-18 23:32:07

First Come First Serve (FCFS)
Jobs are executed on first come, first serve basis.
It is a non-preemptive, pre-emptive scheduling algorithm.
Easy to understand and implement.
Its implementation is based on FIFO queue.
Poor in performance as average wait time is high.
Shortest Job First (SJF)
This is a non-preemptive, pre-emptive scheduling algorithm.
Best approach to minimize waiting time.
Easy to implement in Batch systems where required CPU time is known in advance.
Impossible to implement in interactive systems where required CPU time is not known.
The processer should know in advance how much time process will take.
Priority Based Scheduling
Priority scheduling is a non-preemptive algorithm and one of the most common scheduling algorithms in batch systems.
Each process is assigned a priority. Process with highest priority is to be executed first and so on.
Processes with same priority are executed on first come first served basis.
Priority can be decided based on memory requirements, time requirements or any other resource requirement.
Shortest Remaining Time
Shortest remaining time (SRT) is the preemptive version of the SJF algorithm.
The processor is allocated to the job closest to completion but it can be preempted by a newer ready job with shorter time to completion.
Impossible to implement in interactive systems where required CPU time is not known.
It is often used in batch environments where short jobs need to give preference.
Round Robin Scheduling
Round Robin is the preemptive process scheduling algorithm.
Each process is provided a fix time to execute, it is called a quantum.
Once a process is executed for a given time period, it is preempted and other process executes for a given time period.
Context switching is used to save states of preempted processes.
Multiple-Level Queues Scheduling
Multiple-level queues are not an independent scheduling algorithm. They make use of other existing algorithms to group and schedule jobs with common characteristics.
Multiple queues are maintained for processes with common characteristics.
Each queue can have its own scheduling algorithms.
Priorities are assigned to each queue. PostVer 0

1210775967qqcom • 2020-10-19 20:22:50

<a href="http://www.yvsou.com/wp-content/uploads/sites/30/2020/10/QQ截图202010192021281.png"><img class="alignnone size-medium wp-image-8671" src="http://www.yvsou.com/wp-content/uploads/sites/30/2020/10/QQ截图202010192021281-200x300.png" alt="" width="200" height="300" /></a> PostVer 0

hokyeejaufoxmailcom • 2020-10-19 21:23:22

<ul>
<li>First-Come, First-Served Scheduling(FCFS)</li>
</ul>
The process that requests the CPU first is allocated the CPU first. However, the average waiting time under the FCFS policy is often quite long.
<ul>
<li>Shortest-Job-First Scheduling(SJFS)</li>
</ul>
When the CPU is available, it is assigned to the process that has the smallest next CPU burst.
<ul>
<li>Priority Scheduling(PS)</li>
</ul>
The SJF algorithm is a special case of the general priority scheduling algorithm. The CPU is allocated to the process with the highest priority. Equal-priority processes are scheduled in FCFS order.
<ul>
<li>Round-Robin Scheduling(RR)</li>
</ul>
The RR scheduling algorithm is designed especially for time-sharing systems. A small unit of time called a time quantum is defined and generally from 10 t0 100 milliseconds. The ready queue is treated as a circular queue and every process is sliced into the fixed time quantum. Then the CPU scheduler goes around every ready queue, allocating the CPU to each process for a time interval of up to a time quantum.
<ul>
<li>Multilevel Queue Scheduling</li>
</ul>
A multilevel queue scheduling algorithm partitions the ready queue into several separate queues. The processes are permanently assigned to one queue, generally based on some property of the process, such as memory size, process priority, or process type. Each queue has its own scheduling algorithm.
<ul>
<li>Multilevel Feedback-Queue Scheduling</li>
</ul>
The multilevel feedback queue scheduling algorithm allows a process to move between queues. The idea is to separate processes according to the characteristics of their CPU bursts. If a process uses too much CPU time, it will be moved to a lower-priority queue. PostVer 0

627864699qqcom • 2020-10-21 15:35:40

<a href="http://www.yvsou.com/wp-content/uploads/sites/30/2020/10/discuss.jpg"><img src="http://www.yvsou.com/wp-content/uploads/sites/30/2020/10/discuss-300x162.jpg" alt="" width="300" height="162" class="alignnone size-medium wp-image-8699" /></a> PostVer 0

512858048qqcom • 2020-10-26 15:40:41

First Come First Serve (FCFS): Simplest scheduling algorithm that schedules according to arrival times of processes. First come first serve scheduling algorithm states that the process that requests the CPU first is allocated the CPU first. It is implemented by using the FIFO queue. When a process enters the ready queue, its PCB is linked onto the tail of the queue. When the CPU is free, it is allocated to the process at the head of the queue. The running process is then removed from the queue. FCFS is a non-preemptive scheduling algorithm.

Shortest Job First (SJF): Process which have the shortest burst time are scheduled first.If two processes have the same bust time then FCFS is used to break the tie. It is a non-preemptive scheduling algorithm.

Longest Job First (LJF): It is similar to SJF scheduling algorithm. But, in this scheduling algorithm, we give priority to the process having the longest burst time. This is non-preemptive in nature i.e., when any process starts executing, can’t be interrupted before complete execution.

Shortest Remaining Time First (SRTF): It is preemptive mode of SJF algorithm in which jobs are schedule according to shortest remaining time.

Longest Remaining Time First (LRTF): It is preemptive mode of LJF algorithm in which we give priority to the process having largest burst time remaining.

Round Robin Scheduling: Each process is assigned a fixed time(Time Quantum/Time Slice) in cyclic way.It is designed especially for the time-sharing system. The ready queue is treated as a circular queue. The CPU scheduler goes around the ready queue, allocating the CPU to each process for a time interval of up to 1-time quantum. To implement Round Robin scheduling, we keep the ready queue as a FIFO queue of processes. New processes are added to the tail of the ready queue. The CPU scheduler picks the first process from the ready queue, sets a timer to interrupt after 1-time quantum, and dispatches the process. One of two things will then happen. The process may have a CPU burst of less than 1-time quantum. In this case, the process itself will release the CPU voluntarily. The scheduler will then proceed to the next process in the ready queue. Otherwise, if the CPU burst of the currently running process is longer than 1-time quantum, the timer will go off and will cause an interrupt to the operating system. A context switch will be executed, and the process will be put at the tail of the ready queue. The CPU scheduler will then select the next process in the ready queue.

Priority Based scheduling (Non-Preemptive): In this scheduling, processes are scheduled according to their priorities, i.e., highest priority process is scheduled first. If priorities of two processes match, then schedule according to arrival time. Here starvation of process is possible.

Highest Response Ratio Next (HRRN): In this scheduling, processes with highest response ratio is scheduled. This algorithm avoids starvation. Response Ratio = (Waiting Time + Burst time) / Burst time

Multilevel Queue Scheduling: According to the priority of process, processes are placed in the different queues. Generally high priority process are placed in the top level queue. Only after completion of processes from top level queue, lower level queued processes are scheduled. It can suffer from starvation.

Multi level Feedback Queue Scheduling: It allows the process to move in between queues. The idea is to separate processes according to the characteristics of their CPU bursts. If a process uses too much CPU time, it is moved to a lower-priority queue. PostVer 0

wx287_oz26ft1wt2_isbggtha4lgepaasa • 2020-10-27 14:36:09

CPU scheduling algorithm 1.FCFS (First come, first served) There is no guarantee of turnaround time, 2.SJF (Short jobs preferred) This method has the minimum turnaround time. However, if one of the intermediate tasks is to be executed now, it must wait until the previous task is completed, and the response time cannot be guaranteed. 3. Time slice wheel scheduling, Each task is divided into several time slices, and the response time is guaranteed. 4. Priority scheduling A high-priority process, always executed, can produce hunger. PostVer 0

cfeshete97gmailcom • 2020-10-28 14:01:39

Name: FESHETE CHARLES DE-GAULLE             ID: 2018529627022
<h2>First Come First Serve (FCFS)</h2>
<ul class="list">
<li>Jobs are executed on first come, first serve basis.</li>
<li>It is a non-preemptive, pre-emptive scheduling algorithm.</li>
<li>Easy to understand and implement.</li>
<li>Its implementation is based on FIFO queue.</li>
<li>Poor in performance as average wait time is high.</li>
</ul>
<h2>Shortest Job Next (SJN)</h2>
<ul class="list">
<li>This is also known as <b>shortest job first</b>, or SJF</li>
<li>This is a non-preemptive, pre-emptive scheduling algorithm.</li>
<li>Best approach to minimize waiting time.</li>
<li>Easy to implement in Batch systems where required CPU time is known in advance.</li>
<li>Impossible to implement in interactive systems where required CPU time is not known.</li>
<li>The processer should know in advance how much time process will take.</li>
</ul>
<h2>Priority Based Scheduling</h2>
<ul class="list">
<li>Priority scheduling is a non-preemptive algorithm and one of the most common scheduling algorithms in batch systems.</li>
<li>Each process is assigned a priority. Process with highest priority is to be executed first and so on.</li>
<li>Processes with same priority are executed on first come first served basis.</li>
<li>Priority can be decided based on memory requirements, time requirements or any other resource requirement.</li>
</ul>
<h2>Round Robin Scheduling</h2>
<ul class="list">
<li>Round Robin is the preemptive process scheduling algorithm.</li>
<li>Each process is provided a fix time to execute, it is called a <b>quantum</b>.</li>
<li>Once a process is executed for a given time period, it is preempted and other process executes for a given time period.</li>
<li>Context switching is used to save states of preempted processes.</li>
</ul>
<h2>Multiple-Level Queues Scheduling</h2>
Multiple-level queues are not an independent scheduling algorithm. They make use of other existing algorithms to group and schedule jobs with common characteristics.
<ul class="list">
<li>Multiple queues are maintained for processes with common characteristics.</li>
<li>Each queue can have its own scheduling algorithms.</li>
<li>Priorities are assigned to each queue.</li>
</ul>
For example, CPU-bound jobs can be scheduled in one queue and all I/O-bound jobs in another queue. The Process Scheduler then alternately selects jobs from each queue and assigns them to the CPU based on the algorithm assigned to the queue.

&nbsp; PostVer 0

shatino94163com • 2020-11-10 14:39:09

&nbsp;
<h2>Types of CPU scheduling Algorithm</h2>
There are mainly six types of process scheduling algorithms
<ol>
<li>First Come First Serve (FCFS)</li>
<li>Shortest-Job-First (SJF) Scheduling</li>
<li>Shortest Remaining Time</li>
<li>Priority Scheduling</li>
<li>Round Robin Scheduling</li>
<li>Multilevel Queue Scheduling</li>
</ol>
<img src="https://www.guru99.com/images/1/121119_0541_Schedulinga1.png" />

&nbsp;
<h2>First Come First Serve</h2>
First Come First Serve is the full form of FCFS. It is the easiest and most simple CPU scheduling algorithm. In this type of algorithm, the process which requests the CPU gets the CPU allocation first. This scheduling method can be managed with a FIFO queue.

As the process enters the ready queue, its PCB (Process Control Block) is linked with the tail of the queue. So, when CPU becomes free, it should be assigned to the process at the beginning of the queue.
<h3>Characteristics of FCFS method:</h3>
<ul>
<li>It offers non-preemptive and pre-emptive scheduling algorithm.</li>
<li>Jobs are always executed on a first-come, first-serve basis</li>
<li>It is easy to implement and use.</li>
<li>However, this method is poor in performance, and the general wait time is quite high.</li>
</ul>
<h2><a id="9"></a>Shortest Remaining Time</h2>
The full form of SRT is Shortest remaining time. It is also known as SJF preemptive scheduling. In this method, the process will be allocated to the task, which is closest to its completion. This method prevents a newer ready state process from holding the completion of an older process.

&nbsp;
<h3>Characteristics of SRT scheduling method:</h3>
<ul>
<li>This method is mostly applied in batch environments where short jobs are required to be given preference.</li>
<li>This is not an ideal method to implement it in a shared system where the required CPU time is unknown.</li>
<li>Associate with each process as the length of its next CPU burst. So that operating system uses these lengths, which helps to schedule the process with the shortest possible time.</li>
</ul>
<h2><a id="10"></a>Priority Based Scheduling</h2>
Priority scheduling is a method of scheduling processes based on priority. In this method, the scheduler selects the tasks to work as per the priority.

Priority scheduling also helps OS to involve priority assignments. The processes with higher priority should be carried out first, whereas jobs with equal priorities are carried out on a round-robin or FCFS basis. Priority can be decided based on memory requirements, time requirements, etc.
<h2><a id="11"></a>Round-Robin Scheduling</h2>
Round robin is the oldest, simplest scheduling algorithm. The name of this algorithm comes from the round-robin principle, where each person gets an equal share of something in turn. It is mostly used for scheduling algorithms in multitasking. This algorithm method helps for starvation free execution of processes.
<h3>Characteristics of Round-Robin Scheduling</h3>
<ul>
<li>Round robin is a hybrid model which is clock-driven</li>
<li>Time slice should be minimum, which is assigned for a specific task to be processed. However, it may vary for different processes.</li>
<li>It is a real time system which responds to the event within a specific time limit.</li>
</ul>
<h2><a id="12"></a>Shortest Job First</h2>
SJF is a full form of (Shortest job first) is a scheduling algorithm in which the process with the shortest execution time should be selected for execution next. This scheduling method can be preemptive or non-preemptive. It significantly reduces the average waiting time for other processes awaiting execution.
<h3>Characteristics of SJF Scheduling</h3>
<ul>
<li>It is associated with each job as a unit of time to complete.</li>
<li>In this method, when the CPU is available, the next process or job with the shortest completion time will be executed first.</li>
<li>It is Implemented with non-preemptive policy.</li>
<li>This algorithm method is useful for batch-type processing, where waiting for jobs to complete is not critical.</li>
<li>It improves job output by offering shorter jobs, which should be executed first, which mostly have a shorter turnaround time.</li>
</ul>
<h2><a id="13"></a>Multiple-Level Queues Scheduling</h2>
This algorithm separates the ready queue into various separate queues. In this method, processes are assigned to a queue based on a specific property of the process, like the process priority, size of the memory, etc.

However, this is not an independent scheduling OS algorithm as it needs to use other types of algorithms in order to schedule the jobs.
<h3>Characteristic of Multiple-Level Queues Scheduling:</h3>
<ul>
<li>Multiple queues should be maintained for processes with some characteristics.</li>
<li>Every queue may have its separate scheduling algorithms.</li>
<li>Priorities are given for each queue.</li>
</ul>
<h2> <a id="14"></a>    <span style="text-decoration: underline;"><strong>The Purpose of a Scheduling algorithm</strong></span></h2>
Here are the reasons for using a scheduling algorithm:
<ul>
<li>The CPU uses scheduling to improve its efficiency.</li>
<li>It helps you to allocate resources among competing processes.</li>
<li>The maximum utilization of CPU can be obtained with multi-programming.</li>
<li>The processes which are to be executed are in ready queue.</li>
</ul>
<h3><span style="text-decoration: underline;"><strong>Summary:</strong></span></h3>
<ul>
<li>CPU scheduling is a process of determining which process will own CPU for execution while another process is on hold.</li>
<li>In Preemptive Scheduling, the tasks are mostly assigned with their priorities.</li>
<li>In the Non-preemptive scheduling method, the CPU has been allocated to a specific process.</li>
<li>Burst time is a time required for the process to complete execution. It is also called running time.</li>
<li>CPU utilization is the main task in which the operating system needs to make sure that CPU remains as busy as possible</li>
<li>The number of processes that finish their execution per unit time is known Throughput.</li>
<li>Waiting time is an amount that specific process needs to wait in the ready queue.</li>
<li>It is an amount to time in which the request was submitted until the first response is produced.</li>
<li>Turnaround time is an amount of time to execute a specific process.</li>
<li>Timer interruption is a method that is closely related to preemption,</li>
<li>A dispatcher is a module that provides control of the CPU to the process.</li>
<li>Six types of process scheduling algorithms are:</li>
<li>First Come First Serve (FCFS), 2) Shortest-Job-First (SJF) Scheduling 3) Shortest Remaining Time 4) Priority Scheduling 5) Round Robin Scheduling 6) Multilevel Queue Scheduling</li>
<li>In the First Come First Serve method, the process which requests the CPU gets the CPU allocation first.</li>
<li>In the Shortest Remaining time, the process will be allocated to the task, which is closest to its completion.</li>
<li>In, Priority Scheduling the scheduler selects the tasks to work as per the priority.</li>
<li>In, this Round robin scheduling works on principle, where each person gets an equal share of something in turn</li>
<li>In Shortest job first the shortest execution time should be selected for execution next</li>
<li>In Multilevel scheduling, method separates the ready queue into various separate queues. In this method, processes are assigned to a queue based on a specific property</li>
<li>The CPU uses scheduling to improve its efficiency.</li>
</ul> PostVer 0

shatino94163com • 2020-12-22 14:37:11

1. First come first served scheduling algorithm (FCFS) The service is based on the arrival time of the ready queue. At this time, the ready queue is a FIFO queue. The first come first serve thread, and the last arriving thread cannot preempt the previous serving thread. The advantage of this algorithm is that it is easy to implement, and the disadvantage is obvious. When the CPU process interval changes greatly, the average waiting time will change greatly. 2. Shortest job first scheduling (SJF) As the name implies, the CPU process interval with the shortest execution first. If two process intervals have the same length, they are scheduled according to FCFS. SJF can be preemptive or non preemptive. Its average waiting time is better than that of FCFS. 3. Priority scheduling In fact, the SJF algorithm above is a special priority scheduling, but the definition of priority here is more extensive. The priority of SJF algorithm is defined according to the length of CPU process interval, and the priority here can be some other definitions. Priority scheduling can be preemptive or non preemptive. One of the main problems of priority scheduling is infinite blocking (also known as starvation). If a thread has a low priority, it may take a long time for the thread to execute, or even never execute. One solution is aging (increase the priority of the thread as time goes on) 4. Rotation scheduling (RR) Rotation scheduling is designed specifically for time-sharing systems. It is similar to FCFS, but adds preemption to switch threads. Define a small time unit, called time slice, which is usually 10-100ms. In order to implement RR algorithm, the ready queue is saved as FIFO queue, and the new process is added to the end of the ready queue. The CPU scheduler selects the first process from the ready queue, sets the timer to interrupt after a time slice, and then dispatches the process. If the CPU interval of the process is less than the time slice, the process itself will release the CPU, and the scheduler will continue to process the next process. If the CPU interval of the current process is longer than the time slice, the timer will generate CPU interrupt and implement context switch. Then, the process will be put at the end of the ready queue to continue scheduling the first process in the ready queue. 5. Multi level queue scheduling: Here, processes are grouped, FCFS and SJF algorithms are used in the group, and priority scheduling or rotation scheduling is implemented between groups. However, processes are not allowed to switch between groups. 6. Multi level feedback queue scheduling To allow processes to switch between groups, the main idea is to distinguish processes according to the characteristics of different intervals. If the CPU process takes up too much CPU time, it will be transferred to the lower priority queue. This form of aging prevents hunger. PostVer 0

1224532347qqcom • 2021-01-01 14:53:48

1. First come first served algorithm

Advantages: simple scheduling algorithm

Disadvantages: the average waiting time fluctuates greatly, and the short process may be executed after the long process

The utilization ratio of I / O resources and CPU resources is low. CPU intensive processes will lead to idle I / O devices, and I / O intensive processes will lead to idle CPU

2. Short process first algorithm

The disadvantage of the shortest process first algorithm: the long process may be hungry, because the continuous input short process flow in the ready queue makes the long process unable to obtain the service of the operating system for a long time

3. The highest response ratio first algorithm

It is improved on the basis of the short process first algorithm, which can not be preempted. It focuses on the waiting time of the process and prevents the infinite delay of the long process

4. Time slice rotation algorithm

The interval is too large and the waiting time is too long. In the extreme case, it degenerates into FCFS algorithm

5. Multi level feedback queue algorithm

The size of time slice increases with the increase of priority

If the execution of the current process is not completed in the time slice, it will be reduced to the next priority

I / O-Intensive processes stay at high priority, while CPU intensive processes decline rapidly PostVer 0

2736689890qqcom • 2021-01-06 20:36:58

2018329621239-严宇豪
First-Come, First-Served Scheduling
Shortest-Job-First Scheduling
Priority Scheduling
RR和FCFS有点像但是多了一个时间片的概念 PostVer 0

2736689890qqcom • 2021-01-06 20:37:02

2018329621239-严宇豪
First-Come, First-Served Scheduling
Shortest-Job-First Scheduling
Priority Scheduling
RR和FCFS有点像但是多了一个时间片的概念 PostVer 0

2736689890qqcom • 2021-01-06 20:37:03

2018329621239-严宇豪
First-Come, First-Served Scheduling
Shortest-Job-First Scheduling
Priority Scheduling
RR和FCFS有点像但是多了一个时间片的概念 PostVer 0

2736689890qqcom • 2021-01-06 20:37:06

2018329621239-严宇豪
First-Come, First-Served Scheduling
Shortest-Job-First Scheduling
Priority Scheduling
RR和FCFS有点像但是多了一个时间片的概念 PostVer 0

2736689890qqcom • 2021-01-06 20:37:08

2018329621239-严宇豪
First-Come, First-Served Scheduling
Shortest-Job-First Scheduling
Priority Scheduling
RR和FCFS有点像但是多了一个时间片的概念 PostVer 0