---
title: "Process vs thread and task states"
subject: "Embedded System"
chapter: 6
key: "semester_6/embedded_system:process-thread-and-task-states"
source: https://www.bctengineer.com/q/semester_6/embedded_system/process-thread-and-task-states
site: BCT Engineering
---

# Process vs thread and task states

Embedded System · Chapter 6: RTOS

- Asked in: 2070 Magh, 6 marks
- Video: [2 Tasks, Process And Threads Explained Module 3 6th Sem ECE 2022 Scheme VTU](https://www.youtube.com/watch?v=Sw90ga0beS0) — VTU Academy
- Answer checked by Claude Opus 5.5 (high effort) on 2026-10-14
- Page: https://www.bctengineer.com/q/semester_6/embedded_system/process-thread-and-task-states
- Whole chapter: https://www.bctengineer.com/md/semester_6/embedded_system/chapter-6

## Question

Distinguish between process and thread. Write different states of task with appropriate example.

## Short answer

A process has separate memory space; a thread shares its process's memory but has own stack and registers. Task states: Ready (waiting for CPU, e.g., periodic keypad scan), Running (executing, e.g., scanning keys), Blocked (waiting for event, e.g., UART byte), Dormant (terminated/not created). Transitions occur via scheduler dispatch, preemption, wait, and event signals.

## Answer

#### Process versus thread
| Point | Process | Thread |
|---|---|---|
| Definition | Program in execution with its own resources | Lightweight execution path inside a process |
| Memory | Separate address space | Shares the address space of its process |
| Creation / switching | Slow, heavy | Fast, light |
| Communication | Through IPC mechanisms | Through shared variables |
| Isolation | High | Low (one thread fault can kill the process) |
| Resources | Own files, data, stack, registers | Own stack and registers only |

#### States of a task
A task passes through these states in an RTOS:
```text
            create              dispatch
 (New) ---------> [Ready] <--------------> [Running]
                    ^   pre-empt/time slice   |
                    |                         | wait for event/I/O/delay
          event occurs                        v
                    +----------------- [Blocked/Waiting]
 Running --terminate--> [Terminated/Dormant]
```
- **Ready:** the task is able to run and waits for the CPU. *Example:* a keypad-scan task whose period has elapsed.
- **Running:** the CPU is executing the task's instructions (only one task per CPU). *Example:* the keypad-scan task while it is reading the keys.
- **Blocked (waiting):** the task waits for an event, semaphore, message or delay; it becomes ready when the event occurs. *Example:* a task waiting for a UART byte.
- **Suspended / Terminated (dormant):** the task has been deleted or not yet started, and is not scheduled.

## Check yourself

The answer's key points as multiple-choice questions, with the correct option and why.

1. Which statement about memory correctly separates a process from a thread?
   A. Threads each have a separate address space; processes share one
   B. A process has its own address space; threads of a process share it
   C. Both have separate address spaces
   D. Both share the same address space
   Answer: B. Processes are isolated with separate address spaces, while threads inside a process share its address space. (Key point: Memory model)

2. Compared with a process, a thread has:
   A. Faster creation and switching but lower isolation
   B. Slower creation but higher isolation
   C. Faster creation and higher isolation
   D. Slower switching and lower isolation
   Answer: A. Threads are lightweight and quick to create/switch, but a faulty thread can kill the whole process. (Key point: Cost and isolation)

3. In which state is a task waiting for a UART byte?
   A. Ready
   B. Running
   C. Dormant
   D. Blocked (waiting)
   Answer: D. A task waiting for an event, semaphore, message or delay is blocked and becomes ready when the event occurs. (Key point: Blocked state)

4. What distinguishes the Ready state from the Running state?
   A. Ready tasks are executing; Running tasks wait for events
   B. Ready tasks wait for I/O; Running tasks wait for the CPU
   C. Ready tasks can run but wait for the CPU; only one task per CPU is running
   D. There is no difference on a single CPU
   Answer: C. Ready means able to run but not yet given the CPU; Running means currently executing, one per CPU. (Key point: Ready vs Running)

## Related in Embedded System

- [Different states of a task](https://www.bctengineer.com/question.md?key=semester_6%2Fembedded_system%3Atask-states) — Embedded System, chapter 6
- [Scheduler and task states](https://www.bctengineer.com/question.md?key=semester_6%2Fembedded_system%3Ascheduler-task-states-role) — Embedded System, chapter 6
- [Process versus thread differences](https://www.bctengineer.com/question.md?key=semester_6%2Fembedded_system%3Aprocess-vs-thread) — Embedded System, chapter 6, asked 4×

## Related in other subjects

- [Process vs thread; multithreading advantages](https://www.bctengineer.com/question.md?key=semester_6%2Foperating_system%3Aprocess-thread-multithreading) — Operating System, chapter 2
- [What is process; process vs thread](https://www.bctengineer.com/question.md?key=semester_6%2Foperating_system%3Aprocess-vs-thread-define) — Operating System, chapter 2
- [Process vs thread; context switching](https://www.bctengineer.com/question.md?key=semester_6%2Foperating_system%3Athread-context-switching) — Operating System, chapter 2
- [Process vs thread; user and kernel threads](https://www.bctengineer.com/question.md?key=semester_6%2Foperating_system%3Aprocess-vs-thread-user-kernel-threads) — Operating System, chapter 2