FCFS (First Come First Served) in Operating Systems - Mini Project: Build & Apply

FCFS (First Come First Served) Scheduling Simulation

📖 Scenario: You are managing a simple computer system that runs tasks one after another in the order they arrive. This method is called First Come First Served (FCFS) scheduling.Each task has a name and a time it needs to run. You want to organize these tasks and calculate how long each task waits before it starts running.

🎯 Goal: Create a list of tasks with their arrival order and run times. Then, calculate the waiting time for each task using the FCFS method.

📋 What You'll Learn

Create a list of tasks with exact names and run times

Add a variable to track the current time as tasks are processed

Use a loop to calculate waiting times for each task in FCFS order

Add the waiting time information to each task

💡 Why This Matters

🌍 Real World

FCFS scheduling is used in simple operating systems and batch processing where tasks are handled in the order they arrive.

💼 Career

Understanding FCFS helps in roles like system administration, software development, and IT support where task scheduling and resource management are important.

1

Create the list of tasks

Create a list called tasks with these exact dictionaries in order: {'name': 'Task1', 'run_time': 4}, {'name': 'Task2', 'run_time': 3}, {'name': 'Task3', 'run_time': 1}, {'name': 'Task4', 'run_time': 2}.

Operating Systems

# Create the list of tasks with their names and run times
# Your code here

Hint

Use a list with dictionaries. Each dictionary has keys 'name' and 'run_time' with the exact values given.

2

Add a variable to track current time

Create a variable called current_time and set it to 0. This will track the time as tasks run.

Operating Systems

tasks = [
    {'name': 'Task1', 'run_time': 4},
    {'name': 'Task2', 'run_time': 3},
    {'name': 'Task3', 'run_time': 1},
    {'name': 'Task4', 'run_time': 2}
]
# Create current_time variable and set to 0
# Your code here

Hint

Just create a variable named current_time and assign it zero.

3

Calculate waiting times for each task

Use a for loop with variable task to go through tasks. For each task, add a new key 'waiting_time' with the value of current_time. Then increase current_time by task['run_time'].

Operating Systems

tasks = [
    {'name': 'Task1', 'run_time': 4},
    {'name': 'Task2', 'run_time': 3},
    {'name': 'Task3', 'run_time': 1},
    {'name': 'Task4', 'run_time': 2}
]
current_time = 0
# Use a for loop to add waiting_time to each task and update current_time
# Your code here

Hint

Loop over tasks, set waiting_time to current_time, then add run_time to current_time.

4

Add total waiting time calculation

Create a variable called total_waiting_time and set it to 0. Then use a for loop with variable task to add each task['waiting_time'] to total_waiting_time.

Operating Systems

tasks = [
    {'name': 'Task1', 'run_time': 4},
    {'name': 'Task2', 'run_time': 3},
    {'name': 'Task3', 'run_time': 1},
    {'name': 'Task4', 'run_time': 2}
]
current_time = 0
for task in tasks:
    task['waiting_time'] = current_time
    current_time += task['run_time']
# Calculate total_waiting_time by summing waiting_time of all tasks
# Your code here

Hint

Initialize total_waiting_time to zero, then add each task's waiting_time in a loop.

Practice

1. What does FCFS (First Come First Served) scheduling mean in operating systems?

easy

A. Processes with the shortest time are handled first.

B. Processes are handled in the order they arrive.

C. Processes are handled randomly.

D. Processes with the highest priority are handled first.

Solution

1. Step 1: Understand FCFS concept

   FCFS means tasks are processed in the order they come, like a queue.

2. Step 2: Compare options

   Only Processes are handled in the order they arrive. describes this order-based processing correctly.

3. Final Answer:

   Processes are handled in the order they arrive. -> Option B

4. Quick Check:

   FCFS = Order of arrival [OK]

Hint: Remember: FCFS is like waiting in line [OK]

Common Mistakes:

• Confusing FCFS with priority scheduling
• Thinking shortest tasks go first
• Assuming random order

2. Which of the following is the correct way to describe FCFS scheduling?

easy

A. Processes are scheduled in the order they arrive without preemption.

B. Processes are scheduled based on their priority levels.

C. Processes are scheduled by shortest remaining time first.

D. Processes are scheduled randomly to balance load.

Solution

1. Step 1: Identify FCFS scheduling traits

   FCFS schedules tasks in arrival order and does not interrupt running tasks.

2. Step 2: Match options to traits

   Processes are scheduled in the order they arrive without preemption. correctly states no preemption and order of arrival.

3. Final Answer:

   Processes are scheduled in the order they arrive without preemption. -> Option A

4. Quick Check:

   FCFS = Arrival order + no preemption [OK]

Hint: FCFS runs tasks fully in arrival order [OK]

Common Mistakes:

• Mixing FCFS with priority or shortest job scheduling
• Assuming tasks can be interrupted
• Thinking scheduling is random

3. Given three processes arriving at times 0, 2, and 4 with burst times 5, 3, and 1 respectively, what is the completion time of the second process using FCFS?

medium

A. 10

B. 5

C. 8

D. 9

Solution

1. Step 1: Calculate completion of first process

   Process 1 arrives at 0 and runs for 5 units, finishing at time 5.

2. Step 2: Calculate completion of second process

   Process 2 arrives at 2 but waits until process 1 finishes at 5, then runs for 3 units, finishing at 8.

3. Final Answer:

   8 -> Option C

4. Quick Check:

   Process 2 finishes at 5+3=8 [OK]

Hint: Add burst times in arrival order [OK]

Common Mistakes:

• Starting second process at its arrival time instead of after first finishes
• Adding arrival times incorrectly
• Ignoring waiting time

4. A student wrote this FCFS scheduling code but it gives wrong completion times. What is the likely error?

processes = [(0, 4), (1, 3), (2, 1)]  # (arrival, burst)
completion = []
current_time = 0
for arrival, burst in processes:
    if arrival > current_time:
        current_time = arrival
    completion.append(current_time)
    current_time += burst
print(completion)

medium

A. Not updating current_time after appending completion time.

B. Using a list instead of a queue for processes.

C. Not considering arrival time when updating current_time.

D. Appending completion time before updating current_time.

Solution

1. Step 1: Analyze code logic

   Completion time is appended before current_time is updated with burst time, causing wrong values.

2. Step 2: Identify correct order

   We must update current_time by adding burst before appending completion time to reflect actual finish time.

3. Final Answer:

   Appending completion time before updating current_time. -> Option D

4. Quick Check:

   Update time before recording completion [OK]

Hint: Update current time before saving completion [OK]

Common Mistakes:

• Appending completion time too early
• Ignoring arrival time adjustments
• Confusing process order

5. In an FCFS system, three processes arrive at times 0, 1, and 2 with burst times 4, 2, and 6. If the first process takes longer than expected and runs for 8 units instead of 4, how does this affect the waiting time of the third process?

hard

A. The third process waits longer because the first process delays the queue.

B. The third process waiting time remains the same.

C. The third process starts earlier due to the delay.

D. The third process is skipped and runs immediately.

Solution

1. Step 1: Understand FCFS impact of longer burst

   FCFS runs processes fully in arrival order, so a longer first process delays all others.

2. Step 2: Analyze waiting time effect on third process

   The third process must wait until the first and second finish, so longer first process increases its waiting time.

3. Final Answer:

   The third process waits longer because the first process delays the queue. -> Option A

4. Quick Check:

   Longer first task = longer wait for later tasks [OK]

Hint: Long first task delays all later tasks [OK]

Common Mistakes:

• Assuming later tasks start earlier
• Ignoring impact of burst time changes
• Thinking FCFS skips tasks