Process states (new, ready, running, waiting, terminated) in Operating Systems - Mini Project: Build & Apply

Understanding Process States in Operating Systems

📖 Scenario: Imagine you are learning how a computer manages tasks. Each task is called a process. Processes move through different states as the computer works on them.We will create a simple program that shows these process states and how a process moves from one state to another.

🎯 Goal: You will build a small program that defines the five main process states: new, ready, running, waiting, and terminated. Then, you will simulate moving a process through these states step-by-step.

📋 What You'll Learn

Create a dictionary called process_states with keys as state names and values as descriptions.

Create a variable called current_state to hold the process's current state.

Write a function called move_to_next_state that changes the current_state to the next logical state.

Add a final step to simulate the process moving through all states in order.

💡 Why This Matters

🌍 Real World

Understanding process states helps in knowing how computers manage multiple tasks efficiently and how operating systems schedule and control processes.

💼 Career

This knowledge is essential for roles in software development, system administration, and IT support where managing or optimizing system performance is important.

1

Create the process states dictionary

Create a dictionary called process_states with these exact entries: 'new' mapped to 'Process is being created', 'ready' mapped to 'Process is ready to run', 'running' mapped to 'Process is executing', 'waiting' mapped to 'Process is waiting for an event', and 'terminated' mapped to 'Process has finished execution'.

Operating Systems

# Create the process_states dictionary with exact entries
# Your code here

Hint

Use curly braces {} to create the dictionary and separate each key-value pair with a comma.

2

Set the initial current state

Create a variable called current_state and set it to the string 'new' to represent the process starting in the new state.

Operating Systems

process_states = {
    'new': 'Process is being created',
    'ready': 'Process is ready to run',
    'running': 'Process is executing',
    'waiting': 'Process is waiting for an event',
    'terminated': 'Process has finished execution'
}
# Set current_state to 'new'
# Your code here

Hint

Assign the string 'new' to the variable current_state.

3

Write the function to move to the next state

Write a function called move_to_next_state that takes no arguments and changes the global variable current_state to the next state in this order: new → ready → running → waiting → terminated. Use an if-elif structure to check current_state and update it accordingly.

Operating Systems

process_states = {
    'new': 'Process is being created',
    'ready': 'Process is ready to run',
    'running': 'Process is executing',
    'waiting': 'Process is waiting for an event',
    'terminated': 'Process has finished execution'
}

current_state = 'new'

def move_to_next_state():
    # Your code here

Hint

Remember to declare current_state as global inside the function to modify it.

Use if and elif to check the current state and update it step-by-step.

4

Simulate the process moving through all states

Write code that calls the move_to_next_state function four times to move the process from new to terminated. After each call, add a comment showing the current state variable name current_state to indicate the process's state at that point.

Operating Systems

process_states = {
    'new': 'Process is being created',
    'ready': 'Process is ready to run',
    'running': 'Process is executing',
    'waiting': 'Process is waiting for an event',
    'terminated': 'Process has finished execution'
}

current_state = 'new'

def move_to_next_state():
    global current_state
    if current_state == 'new':
        current_state = 'ready'
    elif current_state == 'ready':
        current_state = 'running'
    elif current_state == 'running':
        current_state = 'waiting'
    elif current_state == 'waiting':
        current_state = 'terminated'

move_to_next_state()  # current_state is now 'ready'
# Your code here

Hint

Call the function move_to_next_state() four times. After each call, add a comment showing the updated current_state.

Practice

1. Which process state indicates that a process is ready to use the CPU but is not currently running?

easy

A. Ready

B. Running

C. Waiting

D. New

Solution

1. Step 1: Understand the meaning of the Ready state

   The Ready state means the process has all resources except the CPU and is waiting to be assigned the CPU.

2. Step 2: Compare with other states

   Running means the process is using the CPU; Waiting means it is waiting for an event; New means it is being created.

3. Final Answer:

   Ready -> Option A

4. Quick Check:

   Ready = waiting for CPU [OK]

Hint: Ready means waiting for CPU, not running yet [OK]

Common Mistakes:

• Confusing Ready with Running
• Thinking Waiting means ready
• Mixing New with Ready

2. Which of the following correctly lists the process states in the order a process typically goes through from start to finish?

easy

A. New -> Ready -> Running -> Waiting -> Terminated

B. New -> Running -> Ready -> Waiting -> Terminated

C. New -> Ready -> Waiting -> Running -> Terminated

D. New -> Waiting -> Ready -> Running -> Terminated

Solution

1. Step 1: Recall the typical process lifecycle

   A process starts as New, then moves to Ready when prepared to run, then Running when executing.

2. Step 2: Understand transitions to Waiting and Terminated

   While running, it may wait for I/O (Waiting), then return to Ready or finish (Terminated).

3. Final Answer:

   New -> Ready -> Running -> Waiting -> Terminated -> Option A

4. Quick Check:

   Correct lifecycle order = New -> Ready -> Running -> Waiting -> Terminated [OK]

Hint: Process starts New, then Ready, then Running [OK]

Common Mistakes:

• Swapping Ready and Running order
• Putting Waiting before Ready
• Skipping New state

3. Consider a process that is currently in the Waiting state. What will happen next when the event it is waiting for occurs?

medium

A. It moves to the Terminated state immediately.

B. It moves directly to Running state.

C. It stays in Waiting until manually terminated.

D. It moves to the Ready state to wait for CPU allocation.

Solution

1. Step 1: Understand the Waiting state

   Waiting means the process is paused, waiting for an event like I/O completion.

2. Step 2: What happens after the event?

   When the event occurs, the process becomes Ready to run but must wait for CPU scheduling.

3. Final Answer:

   It moves to the Ready state to wait for CPU allocation. -> Option D

4. Quick Check:

   Waiting ends -> Ready state [OK]

Hint: Waiting ends, process goes to Ready, not Running directly [OK]

Common Mistakes:

• Thinking Waiting goes directly to Running
• Assuming immediate termination
• Believing process stays Waiting forever

4. A process is stuck in the Running state and never moves to Waiting or Terminated. What is the most likely cause?

medium

A. The process has just been created and is initializing.

B. The process is waiting for CPU allocation.

C. The process is in an infinite loop without I/O or exit.

D. The process has completed and is terminated.

Solution

1. Step 1: Analyze the Running state behavior

   Running means the process is executing instructions on the CPU.

2. Step 2: Understand why it never leaves Running

   If it never moves to Waiting or Terminated, it likely loops endlessly without I/O or exit calls.

3. Final Answer:

   The process is in an infinite loop without I/O or exit. -> Option C

4. Quick Check:

   Infinite loop causes stuck Running [OK]

Hint: Infinite loop keeps process Running endlessly [OK]

Common Mistakes:

• Confusing Running with Ready
• Thinking process is terminated
• Assuming process is waiting for CPU

5. A process moves from Ready to Running, then to Waiting, and back to Ready multiple times before termination. What does this pattern indicate about the process's behavior?

hard

A. The process is stuck in an infinite loop without I/O.

B. The process frequently waits for I/O or external events during execution.

C. The process is terminated and restarted repeatedly.

D. The process is never scheduled to run on the CPU.

Solution

1. Step 1: Understand state transitions

   Moving from Running to Waiting means the process pauses for I/O or events.

2. Step 2: Returning to Ready means it resumes waiting for CPU after I/O completes.

   This cycle repeats until the process finishes and terminates.

3. Final Answer:

   The process frequently waits for I/O or external events during execution. -> Option B

4. Quick Check:

   Running -> Waiting -> Ready cycle = I/O waits [OK]

Hint: Running to Waiting means I/O wait, then Ready to run again [OK]

Common Mistakes:

• Thinking process restarts after termination
• Assuming infinite loop
• Believing process never runs