ΕΙΔΙΚΟΤΗΤΑ: Τεχνικός Δικτύων και Τηλεπικοινωνιών ΕΞΑΜΗΝΟ: Β’

χρονοπρογραμματισμοσ

ΜΑΘΗΜΑ – ΤΥΠΟΣ: ΛΕΙΤΟΥΡΓΙΚΑ ΣΥΣΤΗΜΑΤΑ (Θεωρία)

Περίληψη
Υπάρχουν έξι τύποι αλγορίθμων προγραμματισμού διεργασιών της CPU που είναι: 1) Ο 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

ΟΝΟΜΑΤΕΠΩΝΥΜΟ ΣΠΟΥΔΑΣΤΗ: Στέφανος Μπεληγιάννης

ΟΝΟΜΑΤΕΠΩΝΥΜΟ ΕΚΠΑΙΔΕΥΤΗ : Αποστολίδης Νεόφυτος
Επανομή, Μάρτιος, 2023
Εισαγωγή
Υπάρχουν δύο κατηγορίες Αλγόριθμων Χρονοπρογραμματισμού:

• Οι Προληπτικοί Χρονοπρογραμματισμοί (Preemptive Scheduling) και

• Οι Μη – Προληπτικοί Χρονοπρογραμματισμοί (Non-Preemptive Scheduling)

Προληπτικός Χρονοπρογραμματισμός
Στον Προληπτικό Προγραμματισμό, οι εργασίες ανατίθενται κυρίως με τις προτεραιότητές
τους.

Μερικές φορές είναι σημαντικό να εκτελεστεί μια εργασία με υψηλότερη προτεραιότητα

πριν από μια άλλη εργασία χαμηλότερης προτεραιότητας, ακόμα κι αν η εργασία
χαμηλότερης προτεραιότητας εξακολουθεί να εκτελείται. Η εργασία χαμηλότερης
προτεραιότητας διατηρείται για κάποιο χρονικό διάστημα και συνεχίζεται όταν η εργασία
υψηλότερης προτεραιότητας ολοκληρώσει την εκτέλεσή της.

Μη – Προληπτικός Χρονοπρογραμματισμός
Σε αυτόν τον τύπο χρονοπρογραμματισμού, η CPU έχει εκχωρηθεί σε μια συγκεκριμένη
διαδικασία. Η διαδικασία που κρατά την CPU απασχολημένη θα την απελευθερώσει είτε
όταν υπάρξει εναλλαγή περιβάλλοντος είτε όταν η διαδικασία τερματιστεί. Αυτή είναι η μόνη
μέθοδος χρονοπρογραμματισμού που μπορεί να χρησιμοποιηθεί για διαφορετικές
πλατφόρμες υλικού. Αυτό συμβαίνει επειδή δεν χρειάζεται ειδικό υλικό (για παράδειγμα,
χρονόμετρο) όπως ο προληπτικός προγραμματισμός.

Πότε έχουμε Προληπτικό και πότε Μη-Προληπτικό

Χρονοπρογραμματισμό
Για να προσδιορίσουμε εάν ο προγραμματισμός είναι προληπτικός ή μη, εξετάζουμε τις
ακόλουθες τέσσερις παραμέτρους:

1. Μια διαδικασία αλλάζει από την κατάσταση εκτέλεσης στην κατάσταση αναμονής.
2. Η συγκεκριμένη διαδικασία αλλάζει από την κατάσταση λειτουργίας στην κατάσταση
ετοιμότητας.
3. Η συγκεκριμένη διαδικασία αλλάζει από την κατάσταση αναμονής στην κατάσταση
ετοιμότητας.
4. Η διαδικασία ολοκλήρωσε την εκτέλεσή της και τερματίστηκε.

Όταν ισχύουν μόνο οι προϋποθέσεις 1 και 4, ο προγραμματισμός ονομάζεται μη-

προληπτικός.

Σε κάθε άλλη περίπτωση οι προγραμματισμοί είναι προληπτικοί.

Κριτήρια προγραμματισμού CPU

Ένας αλγόριθμος προγραμματισμού CPU προσπαθεί να μεγιστοποιήσει και να
ελαχιστοποιήσει τα ακόλουθα:

1
Μεγιστοποιείται:
Χρήση CPU: Η χρήση της CPU είναι η κύρια εργασία για την οποία το λειτουργικό σύστημα
πρέπει να βεβαιωθεί ότι η CPU παραμένει όσο το δυνατόν πιο απασχολημένη. Ο δείκτης
χρήσης μπορεί να κυμαίνεται από 0 έως 100 τοις εκατό. Ωστόσο, για το RTOS (Real Time
Operating System), μπορεί να κυμαίνεται από 40 τοις εκατό για το χαμηλό επίπεδο και 90
τοις εκατό για το υψηλό επίπεδο.

Διακίνηση: Ο αριθμός των διεργασιών που ολοκληρώνουν την εκτέλεσή τους ανά μονάδα
χρόνου είναι γνωστός ως Διακίνηση. Έτσι, όταν η CPU είναι απασχολημένη με την εκτέλεση
της διαδικασίας, εκείνη η στιγμή που εκτελείται η εργασία και γενικότερα η εργασία που
ολοκληρώνεται ανά μονάδα χρόνου ονομάζεται διακίνηση.

Ελαχιστοποιείται:
Χρόνος αναμονής: Ο χρόνος αναμονής είναι ο χρόνος που χρειάζεται συγκεκριμένη
διαδικασία για να περιμένει στην ουρά έτοιμων διαδικασιών προς εκτέλεση.

Χρόνος απόκρισης: Είναι το χρονικό διάστημα κατά το οποίο υποβλήθηκε το αίτημα μέχρι
να παραχθεί η πρώτη απάντηση.

Χρόνος διεκπεραίωσης: Ο χρόνος διεκπεραίωσης είναι ένα χρονικό διάστημα για την
εκτέλεση μιας συγκεκριμένης διαδικασίας. Είναι ο υπολογισμός του συνολικού χρόνου που
δαπανάται αναμονή για να μπει στη μνήμη, αναμονή στην ουρά και εκτέλεση στην CPU. Η
περίοδος μεταξύ του χρόνου υποβολής της διαδικασίας έως του χρόνου ολοκλήρωσης είναι
ο χρόνος διεκπεραίωσης.

Χρονοδιακόπτης διαστήματος
Η διακοπή του χρονοδιακόπτη είναι μια μέθοδος που σχετίζεται στενά με την πρόληψη. Όταν
μια συγκεκριμένη διεργασία λάβει την εκχώρηση της CPU, ένας χρονοδιακόπτης μπορεί να
ρυθμιστεί σε ένα καθορισμένο διάστημα. Τόσο η διακοπή του χρονοδιακόπτη όσο και η
προκατάληψη αναγκάζουν μια διαδικασία να επιστρέψει τη CPU πριν ολοκληρωθεί η έκρηξη
της CPU.

2
Το μεγαλύτερο μέρος του πολλαπλού προγραμματισμένου λειτουργικού συστήματος
χρησιμοποιεί κάποια μορφή χρονοδιακόπτη για να αποτρέψει μια διεργασία από το να
δεσμεύσει το σύστημα για πάντα.

Τι είναι το Dispatcher;
Είναι μια μονάδα που παρέχει έλεγχο της CPU στη διαδικασία. Ο διεκπεραιωτής πρέπει να
είναι γρήγορος, ώστε να μπορεί να εκτελείται σε κάθε διακόπτη περιβάλλοντος. Η
καθυστέρηση αποστολής είναι ο χρόνος που χρειάζεται ο προγραμματιστής CPU για να
σταματήσει μια διαδικασία και να ξεκινήσει μια άλλη.

Λειτουργίες που εκτελούνται από το Dispatcher:

• Εναλλαγή περιβάλλοντος
• Μετάβαση σε λειτουργία χρήστη
• Μετακίνηση στη σωστή θέση στο πρόγραμμα που φορτώθηκε πρόσφατα.

Αλγόριθμοι Χρονοπρογραμματισμού Λειτουργίας CPU

Υπάρχουν κυρίως 6 αλγόριθμοι χρονοπρογραμματισμού της ΚΜΕ τους οποίους θα
αναφέρουμε στην Αγγλική Ορολογία τους. Στην εργασία αυτή θα αντιμετωπίσουμε διεξοδικά
μόνο τους 1, 2 και 5 αλγορίθμους που είναι και οι πιο συνηθισμένοι.

1. 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

3
First Come First Serve (FCFS)
• Προσφέρει αλγόριθμο μη-προληπτικού και προληπτικού χρονοπρογραμματισμού.
• Οι εργασίες εκτελούνται πάντα με σειρά προτεραιότητας
• Είναι εύκολο να εφαρμοστεί και να χρησιμοποιηθεί.
• Ωστόσο, αυτή η μέθοδος είναι χαμηλής απόδοσης και ο γενικός χρόνος αναμονής
είναι αρκετά υψηλός.

Πρόγραμμα FCFS σε Java

C:\iek\B-EXAM\OS-II-
ORF\THEORY\XronodFcfs\src\xronodfcfs\XronodFcfs.java
/*
* To change this license header, choose License Headers in Project
Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
package xronodfcfs;

import java.util.Scanner;

/**
*
* @author pbeli (Παναγιώτης Μπεληγιάννης)
*/
public class XronodFcfs {

/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// float mxan, mxap;
// Οργανώνει το αντικείμενο scanner
System.out.println("Enter the number of processes");
Scanner in = new Scanner(System.in);
// Διαβάζει τον αριθμό των Εργασιών
int numberOfProcesses = in.nextInt();
// Οργανώνει στην μνήμη τα μητρώα που θα κρατήσουν τα
δεδομένα των Εργασιών
int pid[] = new int[numberOfProcesses];
int bt[] = new int[numberOfProcesses];
int ar[] = new int[numberOfProcesses];
int ct[] = new int[numberOfProcesses];
int ta[] = new int[numberOfProcesses];
int wt[] = new int[numberOfProcesses];
// Εισάγει γιά όλες τις εργασίες τους χρόνους άφιξης και
διάρκειας
for(int i=0;i<numberOfProcesses;i++) {
System.out.println("Enter process " + (i+1) + " arrival
time: ");
ar[i] = in.nextInt();
System.out.println("Enter process " + (i+1) + " burst
time: ");
bt[i] = in.nextInt();
pid[i] = i+1;
}
int temp;
// Ταξινομεί τις εργασίες κατά τον χρόνο άφιξής τους
for (int i=0;i<numberOfProcesses;i++) {

4
 for (int j=i+1;j<numberOfProcesses;j++) {
if(ar[i]>ar[j]) {
temp = ar[i];
ar[i] = ar[j];
ar[j] = temp;

temp = pid[i];
pid[i] = pid[j];
pid[j] = temp;
temp = bt[i];
bt[i] = bt[j];
bt[j] = temp;
}
}
}
//τυπώνει μία κενή γραμμή
System.out.println();
//Υπολογίζει το τέλος της 1ης εργασίας
ct[0] = bt[0] + ar[0];
//και απο τον χρόνο της 1ης υπολογίζει τους χρόνους τέλους
των υπολοίπων
//με την σειρά του χρόνου άφιξης
for(int i=1;i<numberOfProcesses;i++) {
ct[i] = ct[i-1]+bt[i];
}
//Υπολογίζει για κάθε εργασία τα υπόλοιπα στοιχεία
for(int i=0;i<numberOfProcesses;i++) {
//Χρόνος εκτέλεσης + Χρόνος αναμονης
ta[i] = ct[i] - ar[i];
// Υπολογίζει τον χρόνο αναμονής
wt[i] = ta[i] - bt[i];
}
//Εκτυπώνει τα αποτελέσματα.
System.out.println("Process\t\tAT\t\tΒΤ\t\tCT\t\tTAT\t\tWT");
for(int i=0;i<numberOfProcesses;i++) {

System.out.println(pid[i]+"\t\t\t"+ar[i]+"\t\t"+bt[i]+"\t\t"+ct[i]+"\
t\t"+ta[i]+"\t\t"+wt[i]);
}
double twt=0.0;
for (int i=0;i<numberOfProcesses;i++) {
twt=twt+wt[i];
}
twt=twt/numberOfProcesses;
System.out.println("Χρόνος Αναμονής : "+ twt);
twt=0.0;
for (int i=0;i<numberOfProcesses;i++) {
twt=twt+ta[i];
}
twt=twt/numberOfProcesses;
System.out.println("Χρόνος Απόκρισης : "+ twt);
System.out.println("Gantt Chart: ");
for(int i=0;i<numberOfProcesses;i++) {
System.out.print("P" + pid[i]+" ");
for(int j=0;j<ar[i];j++){
System.out.print(" ");
}
for(int j=0;j<wt[i];j++){
System.out.print("W");
}
for(int j=0;j<bt[i];j++){

5
 System.out.print("B");
}
System.out.println("");
}

Παράδειγμα
Δεδομένα

Αποτελέσματα

ΑΤ=Χρόνος Άφιξης, ΒΤ=Burst Time= Χρόνος Εκτέλεσης, CT=Completion Time=Χρόνος

Ολοκλήρωσης με αρχή το 0, ΤΑΤ=Χρόνος Ολοκλήρωσης – Χρόνος Άφιξης και WT=Χρόνος
αναμονής.

Στο διάγραμμα GANTT το B σημαίνει Burst δηλαδή εκχώρηση στην CPU και εκτέλεση της
διαδικασίας.

Το W σημαίνει Wait δηλαδή αναμονή.

6
Shortest Job First (SJF)
• Συνδέεται με κάθε εργασία ως μονάδα χρόνου προς ολοκλήρωση.
• Σε αυτή τη μέθοδο, όταν η CPU είναι διαθέσιμη, η επόμενη διεργασία ή εργασία με
τον συντομότερο χρόνο ολοκλήρωσης θα εκτελεστεί πρώτη.
• Εφαρμόζεται με μη προληπτική πολιτική.
• Αυτή η μέθοδος αλγορίθμου είναι χρήσιμη για επεξεργασία τύπου παρτίδας, όπου η
αναμονή για την ολοκλήρωση των εργασιών δεν είναι κρίσιμη.
• Βελτιώνει την απόδοση της εργασίας προσφέροντας μικρότερες εργασίες, οι οποίες
θα πρέπει να εκτελεστούν πρώτα, οι οποίες έχουν ως επί το πλείστον μικρότερο
χρόνο διεκπεραίωσης.

Πρόγραμμα SJF σε Java

C:\iek\B-EXAM\OS-II-
ORF\THEORY\XronodSJF\src\xronodSJF\XronodSJF.java
/*
* To change this license header, choose License Headers in Project
Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
package xronodSJF;

import java.util.Scanner;

/**
*
* @author pbeli (Παναγιώτης Μπεληγιάννης)
*/
public class XronodSJF {

/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// float mxan, mxap;
// Οργανώνει το αντικείμενο scanner
System.out.println("Enter the number of processes");
Scanner in = new Scanner(System.in);
// Διαβάζει τον αριθμό των Εργασιών
int numberOfProcesses = in.nextInt();
// Οργανώνει στην μνήμη τα μητρώα που θα κρατήσουν τα
δεδομένα των Εργασιών
int pid[] = new int[numberOfProcesses];
int bt[] = new int[numberOfProcesses];
int ar[] = new int[numberOfProcesses];
int ct[] = new int[numberOfProcesses];
int ta[] = new int[numberOfProcesses];
int wt[] = new int[numberOfProcesses];
// Εισάγει γιά όλες τις εργασίες τους χρόνους άφιξης και
διάρκειας
for(int i=0;i<numberOfProcesses;i++) {
System.out.println("Enter process " + (i+1) + " arrival
time: ");
ar[i] = in.nextInt();
System.out.println("Enter process " + (i+1) + " brust
time: ");

7
 bt[i] = in.nextInt();
pid[i] = i+1;
}
int temp;
// Ταξινομεί τις εργασίες κατά τον χρόνο άφιξής τους
for (int i=1;i<numberOfProcesses;i++) {
for (int j=i+1;j<numberOfProcesses;j++) {
if(bt[i]>bt[j]) {
temp = ar[i];
ar[i] = ar[j];
ar[j] = temp;

temp = pid[i];
pid[i] = pid[j];
pid[j] = temp;
temp = bt[i];
bt[i] = bt[j];
bt[j] = temp;
}
}
}
//τυπώνει μία κενή γραμμή
System.out.println();
//Υπολογίζει το τέλος της 1ης εργασίας
ct[0] = bt[0] + ar[0];
//και απο τον χρόνο της 1ης υπολογίζει τους χρόνους τέλους
των υπολοίπων
//με την σειρά του χρόνου άφιξης
for(int i=1;i<numberOfProcesses;i++) {
ct[i] = ct[i-1]+bt[i];
}
//Υπολογίζει για κάθε εργασία τα υπόλοιπα στοιχεία
for(int i=0;i<numberOfProcesses;i++) {
//Χρόνος εκτέλεσης + Χρόνος αναμονης
ta[i] = ct[i] - ar[i];
// Υπολογίζει τον χρόνο αναμονής
wt[i] = ta[i] - bt[i];
}
//Εκτυπώνει τα αποτελέσματα.
System.out.println("Process\t\tAT\t\tΒΤ\t\tCT\t\tTAT\t\tWT");
for(int i=0;i<numberOfProcesses;i++) {

System.out.println(pid[i]+"\t\t\t"+ar[i]+"\t\t"+bt[i]+"\t\t"+ct[i]+"\
t\t"+ta[i]+"\t\t"+wt[i]);
}
double twt=0.0;
for (int i=0;i<numberOfProcesses;i++) {
twt=twt+wt[i];
}
twt=twt/numberOfProcesses;
System.out.println("Χρόνος Αναμονής : "+ twt);
twt=0.0;
for (int i=0;i<numberOfProcesses;i++) {
twt=twt+ta[i];
}
twt=twt/numberOfProcesses;
System.out.println("Χρόνος Απόκρισης : "+ twt);
System.out.println("Gantt Chart: ");
for(int i=0;i<numberOfProcesses;i++) {
System.out.print("P" + pid[i]+" ");
for(int j=0;j<ar[i];j++){

8
 System.out.print(" ");
}
for(int j=0;j<wt[i];j++){
System.out.print("W");
}
for(int j=0;j<bt[i];j++){
System.out.print("B");
}
System.out.println("");
}

Παράδειγμα
Στο παράδειγμα του FCFS έχουμε τα εξής αποτελέσματα:

Round-Robin
• Το Round Robin είναι ένας προληπτικός αλγόριθμος
• Η CPU μετατοπίζεται στην επόμενη διεργασία μετά από σταθερό χρονικό διάστημα,
το οποίο ονομάζεται time quantum/time slice.
• Η διεργασία που έχει προεπιλεγεί προστίθεται στο τέλος της ουράς.
• Το Round Robin είναι ένα υβριδικό μοντέλο που λειτουργεί με ρολόι
• Το χρονικό τεμάχιο πρέπει να είναι ελάχιστο, το οποίο εκχωρείται για μια
συγκεκριμένη εργασία που πρέπει να υποβληθεί σε επεξεργασία. Ωστόσο, μπορεί να
διαφέρει από λειτουργικό σύστημα.
• Είναι ένας αλγόριθμος πραγματικού χρόνου που ανταποκρίνεται στο συμβάν εντός
συγκεκριμένου χρονικού ορίου.
• Το Round Robin είναι ένας από τους παλαιότερους, πιο δίκαιους και ευκολότερους
αλγόριθμους.
• Ευρέως χρησιμοποιούμενη μέθοδος προγραμματισμού στα παραδοσιακά
λειτουργικά συστήματα.

Πρόγραμμα RR σε Java
C:\iek\B-EXAM\OS-II-
ORF\THEORY\XronRR\src\xronRR\XronoRR.java

package xronRR;

9
import java.util.Scanner;

/**
*
* @author smpel (Στέφανος Μπεληγιάννης)
*/
public class XronoRR {
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// float mxan, mxap;
// Οργανώνει το αντικείμενο scanner
System.out.println("Enter the number of processes");
Scanner in = new Scanner(System.in);
// Διαβάζει τον αριθμό των Εργασιών
int numberOfProcesses = in.nextInt();
int ndim = numberOfProcesses;
// Οργανώνει στην μνήμη τα μητρώα που θα κρατήσουν τα
δεδομένα των Εργασιών
int pid[] = new int[numberOfProcesses];
int bt[] = new int[numberOfProcesses];
int btt[] = new int[numberOfProcesses];
int ar[] = new int[numberOfProcesses];
int ct[] = new int[numberOfProcesses];
int ta[] = new int[numberOfProcesses];
int wt[] = new int[numberOfProcesses];
String[] s = new String[ndim];
// Εισάγει γιά όλες τις εργασίες τους χρόνους άφιξης και
διάρκειας
for(int i=0;i<numberOfProcesses;i++) {
System.out.println("Enter process " + (i+1) + " arrival
time: ");
ar[i] = in.nextInt();
System.out.println("Enter process " + (i+1) + " burst
time: ");
bt[i] = in.nextInt();
btt[i] = bt[i];
pid[i] = i+1;
s[i] = "";
}
int temp;
// Ταξινομεί τις εργασίες κατά τον χρόνο άφιξής τους
for (int i=0;i<numberOfProcesses;i++) {
for (int j=i+1;j<numberOfProcesses;j++) {
if(ar[i]>ar[j]) {
temp = ar[i];
ar[i] = ar[j];
ar[j] = temp;

temp = pid[i];
pid[i] = pid[j];
pid[j] = temp;
temp = bt[i];
bt[i] = bt[j];
bt[j] = temp;
temp = btt[i];
btt[i] = btt[j];
btt[j] = temp;
}

10
 }
}
//τυπώνει μία κενή γραμμή
System.out.println();
//Χρόνος αυτή την στιγμή
int nt = 0;
//Τρεχουσα διεργασία, ξεκινάμε με την 1η
int ip = 0;
boolean completed = false;
while (completed == false) {
nt++;
for (int i = 0; i < numberOfProcesses; i++){
if (i == ip) {
if ((nt >= ar[i]) && (btt[i] > 0)) {
s[i] = s[i] + "B";
btt[i]--;
}
else {
if (nt < ar[i]) s[i] = s[i] + " ";
}

for (int j = 0; j < numberOfProcesses; j++) {

if (j != i) {
if ((nt >= ar[j]) && (nt>=ar[i])) {
if ((btt[j] > 0) && (btt[i]>0)) {
s[j] = s[j] + "W";
wt[j]++;
}
}
}
}

ip++;
if (ip >= numberOfProcesses) {
ip = 0;
}
}

}
completed = true;
for (int k = 0; k < numberOfProcesses; k++) {
completed = completed && (btt[k]<=0);
}
}
//Υπολογίζει για κάθε εργασία τα υπόλοιπα στοιχεία
for(int i=0;i<numberOfProcesses;i++) {
ct[i] = ar[i] + wt[i] + bt[i];
//Χρόνος εκτέλεσης + Χρόνος αναμονης
ta[i] = ct[i] - ar[i];
// Υπολογίζει τον χρόνο αναμονής
wt[i] = ta[i] - bt[i];
}
//Εκτυπώνει τα αποτελέσματα.
System.out.println("Process\t\t\tAT\t\tΒΤ\t\tCT\t\tTAT\t\tWT");
for(int i=0;i<numberOfProcesses;i++) {

System.out.println(pid[i]+"\t\t\t"+ar[i]+"\t\t"+bt[i]+"\t\t"+ct[i]+"\
t\t"+ta[i]+"\t\t"+wt[i]);
}
double twt=0.0;
for (int i=0;i<numberOfProcesses;i++) {

11
 twt = twt+wt[i];
}
twt=twt/numberOfProcesses;
System.out.println("Χρόνος Αναμονής : "+ twt);
twt=0.0;
for (int i=0;i<numberOfProcesses;i++) {
twt=twt+ta[i];
}
twt=twt/numberOfProcesses;
System.out.println("Χρόνος Απόκρισης : "+ twt);
System.out.println("Gantt Chart: ");
for(int i=0;i<numberOfProcesses;i++) {
System.out.print("P" + pid[i]+" ");
System.out.println(s[i]);
System.out.println("");
}

}
}
Αποτελέσματα στο προηγούμενο παράδειγμα αιτημάτων

12
Ορολογία
• Χρόνος ριπής/Χρόνος εκτέλεσης (Burst Time/Execution Time): Είναι ο χρόνος που
απαιτείται από τη διαδικασία για να ολοκληρωθεί η εκτέλεση. Ονομάζεται επίσης
χρόνος λειτουργίας.
• Ώρα άφιξης (Arrival Time): όταν μια διαδικασία εισέρχεται σε κατάσταση
ετοιμότητας
• Ώρα λήξης(Finish Time): όταν ολοκληρωθεί η διαδικασία και βγείτε από ένα σύστημα
• Πολυπρογραμματισμός (Multiprogramming): Ένας αριθμός προγραμμάτων που
μπορούν να υπάρχουν ταυτόχρονα στη μνήμη.
• Ανεξάρτητες Εργασίες (Jobs) : Είναι ένα είδος προγραμμάτων χωρίς κανενός είδους
αλληλεπίδραση με τον χρήστη.
• Χρήστης (User): Είναι ένα είδος προγράμματος που έχει αλληλεπίδραση με τον
χρήστη.
• Διαδικασία (Process): Είναι η αναφορά που χρησιμοποιείται τόσο για την εργασία
(job) όσο και για την εργασία χρήστη (user).
• Κύκλος ριπής CPU/IO (CPU/IO burst cycle): Χαρακτηρίζει την εκτέλεση διαδικασίας, η
οποία εναλλάσσεται μεταξύ της δραστηριότητας CPU και I/O. Οι χρόνοι της CPU είναι
συνήθως μικρότεροι από τον χρόνο εισόδου/εξόδου.

13
Βιβλιογραφία
• https://www.guru99.com/cpu-scheduling-
algorithms.html#:~:text=Six%20types%20of%20process%20scheduling%20algorithm
s%20are%3A%20First%20Come%20First,%2C%206)%20Multilevel%20Queue%20Sch
eduling.

14