Threads: what they share, user-level vs kernel-level threads

0 · Recall Warm-up

Answer from memory first. Answers are in the Answer Vault at the bottom.

1. After fork, are variables shared? from Lesson 1.1.2
2. Which segment holds local variables? from Lesson 1.1.1
3. Interrupts come from? from Lesson 0.1.2

1 · The Hook

A web browser downloads an image, plays a video and responds to your scroll, all at once, inside one process. It uses threads: several lines of execution sharing the same memory. Threads are cheaper than processes and share data easily, which is also why they need careful synchronization (Phase 3). GATE asks what threads share and how user-level and kernel-level threads differ.

3 · Core Concept

Predict First — the answer

Yes. Threads of the same process share global data (unlike processes after fork, which get copies).

In plain words

A thread is one path of execution inside a process. All threads of a process share its code, its global data, its heap and its open files, but each thread has its own stack, registers and program counter (so each can be at a different line, inside different function calls).

1. Shared vs private

2. Why threads?

• Cheaper than processes: creating a thread and switching between threads of the same process costs much less (no new address space).
• Sharing data is easy (same memory).
• Responsiveness and use of multiple CPU cores.

3. User-level vs kernel-level threads

4. Multithreading models (user threads → kernel threads)

• Many-to-one: many user threads on one kernel thread (one blocking call blocks all).
• One-to-one: each user thread has its own kernel thread (Linux, Windows); true parallelism, more overhead.
• Many-to-many: many user threads multiplexed onto a smaller or equal number of kernel threads.

4 · Visual

One process, three threads

 +--------------------------------------------+
 |  code      |  global data  |  heap  | files |   <- shared by all threads
 +--------------------------------------------+
 |  thread 1        thread 2        thread 3   |
 |  [stack 1]       [stack 2]       [stack 3]  |   <- private
 |  PC, regs        PC, regs        PC, regs   |
 +--------------------------------------------+

5 · Worked Examples

Example 1 Easy

Do two threads of a process share their local variables?

Solution

No: locals live on each thread's own stack.

Example 2 Medium

A process uses only user-level threads. One thread makes a blocking read. What happens to the other threads?

Solution

They all block: the kernel sees one process, which is now waiting.

Example 3 GATE

Which is cheaper: switching between two threads of the same process, or between two processes?

Solution

Between threads of the same process: no change of address space is needed.

6 · GATE Traps

• Threads share the heap and globals but not the stack or registers.
• User-level threads block together on a blocking system call.
• Kernel threads can run in parallel on multiple CPUs; many-to-one user threads cannot.
• fork copies memory; threads share it.

7 · Memory Hook

"Threads share the house, each has its own notebook (stack)."

8 · Connect the Dots

Threads share memory automatically. Separate processes don't, so they need inter-process communication: shared memory regions, messages or pipes, the topic of the next lesson.

9 · Self-Test

GATE format. Try every question before opening the vault.

Q1 · MSQ · 2 mark(s) — Sharing

Which are shared by all threads of a process?

1. (A) Global variables
2. (B) Stack
3. (C) Open files
4. (D) Heap

Q2 · MCQ · 1 mark(s) — Private

Which does each thread have its own copy of?

1. (A) Code
2. (B) Heap
3. (C) Open-file table
4. (D) Program counter

Q3 · MCQ · 1 mark(s) — User-level threads

With purely user-level threads, a blocking system call by one thread:

1. (A) crashes the process
2. (B) blocks the whole process
3. (C) blocks only that thread
4. (D) is impossible

Q4 · MCQ · 1 mark(s) — Models

Linux maps each user thread to its own kernel thread. This is the:

1. (A) many-to-many model
2. (B) one-to-one model
3. (C) many-to-one model
4. (D) no-thread model

Q5 · MCQ · 1 mark(s) — Cost

Which is the main reason threads are cheaper to create than processes?

1. (A) They share the existing address space.
2. (B) They run in kernel mode.
3. (C) They never make system calls.
4. (D) They have no stack.

10 · Rule Card

• Thread = path of execution inside a process; shares code, data, heap, open files; private stack, registers, PC, thread ID.
• Threads are cheaper to create and switch than processes.
• User-level: fast, kernel unaware, one block blocks all, no parallelism. Kernel-level: kernel-scheduled, independent blocking, parallel on multiple cores.
• Models: many-to-one, one-to-one, many-to-many.

11 · Concept Ledger

Unlocked in this lesson. From here on, these terms may be used.

threadshared and private thread resourcesbenefits of threadsuser-level threadskernel-level threadsblocking behaviourmany-to-one, one-to-one and many-to-many models