Wat is het verschil tussen een proces en een thread?

Question

IT Interview Practice · Accepted Answer

Een **proces** is een draaiend programma met zijn eigen geïsoleerde geheugen (adresruimte); een **thread** is een uitvoeringseenheid *binnen* een proces. Eén proces kan veel threads bevatten, en die threads **delen** het geheugen van het proces — maar elk proces is geïsoleerd van elk ander.

## Wat elk bezit

```text
PROCESS A                          PROCESS B
┌─────────────────────────────┐    ┌───────────────┐
│ address space (code/heap)   │    │ address space │
│ file descriptors, PID       │    │  (isolated)   │
│ ┌────────┐ ┌────────┐       │    │  ┌────────┐   │
│ │thread 1│ │thread 2│  ...  │    │  │thread 1│   │
│ │ stack  │ │ stack  │       │    │  │ stack  │   │
│ │ regs/PC│ │ regs/PC│       │    │  └────────┘   │
│ └────────┘ └────────┘       │    └───────────────┘
│  ▲ shared heap, globals, fds│
└─────────────────────────────┘
```

- **Per proces:** adresruimte, open file descriptors, PID — volledig geïsoleerd door de kernel.
- **Per thread:** een eigen **stack**, registers en program counter (PC).
- **Gedeeld tussen threads in een proces:** de heap, globale variabelen en open files.

## De praktische afweging

- **Threads** zijn goedkoop om te maken en communiceren direct (gedeeld geheugen) — maar een bug in één thread (foute pointer, crash) haalt het hele proces onderuit, en gedeelde data heeft locks nodig.
- **Processen** zijn zwaarder en moeten IPC gebruiken om te praten, maar isolatie betekent dat een crashend proces een ander niet corrumpeert — het model dat browsers gebruiken om tabs te sandboxen.

Context-switchen **tussen threads** van hetzelfde proces is goedkoper dan tussen processen, omdat de memory map (en zijn TLB-entries) niet hoeft te veranderen.

## Waarom het belangrijk is

"Process vs thread" is een van de meest voorkomende OS-interviewvragen, omdat het antwoord echte ontwerpkeuzes stuurt: threads voor shared-memory-parallellisme binnen een service, aparte processen voor fault-isolatie en security-sandboxing. Precies weten wat gedeeld is (heap, fds) versus privé (stack, registers) is ook de basis om race conditions te begrijpen en waarom synchronisatie nodig is.

Wat elk bezit

De praktische afweging

Waarom het belangrijk is

Gerelateerde vragen