Threads and Scheduling

Flashcards covering key concepts related to thread states, scheduling, and performance measures.

Response Time

Time between a process's arrival in the ready queue and its first assignment to the CPU

Turnaround Time

Time between a process's arrival in the ready queue and its completion

Throughput

Number of processes that start and complete during the observation interval

Wait Time

Total time a process spends waiting for the CPU (includes response time)

Response Time Formula

R = t1

Wait Time Formula

W = R + t3

CPU Burst Time Formula

B = t2 + t4

Turnaround Time Formula

T = B + W

FCFS Throughput

Number of processes divided by total time units (e.g. 4 processes / 15 units = 0.267 proc/unit)

FCFS Response Time

Time from process arrival to first CPU assignment (non-preemptive — waiting in queue)

FCFS Wait Time

Response time plus any additional waiting during execution

FCFS Turnaround Time

CPU burst time plus wait time

Running (Thread State)

Thread is currently executing on the CPU

Ready (Thread State)

Thread is prepared to run and awaits CPU allocation

Blocked (Thread State)

Thread cannot proceed until an external event (e.g. I/O) completes

spawn

Create a new thread

block

Move a thread to blocked state (e.g. I/O request)

unblock

Return a thread to ready state after an event completes

finish

Thread terminates after execution

User-Level Thread (ULT)

Threads handled entirely by the application thread library — kernel does not know about individual threads

Kernel-Level Thread (KLT)

Threads managed directly by the OS kernel — kernel maintains context for each thread

Suspending a process

All of its threads become blocked

Terminating a process

All of its threads are finished

Process Running (thread states)

One thread is Running

Process Ready (thread states)

All threads are Ready awaiting CPU

Process Blocked (thread states)

All threads are Blocked e.g. waiting for I/O

Single-Threaded Server (RPC)

Process 1 blocks while waiting for RPC response — server handles request while other threads may be idle

One-Thread-Per-Server (RPC)

Each server runs its own thread — client thread blocks

Multithreaded Application (RPC)

Two client threads issue independent RPCs to different servers simultaneously — overlapping latency reduces total wait time