Processes vs Threads

An Operating System Process is an independent execution container created by the OS kernel. Each process is allocated its own private Virtual Address Space mapped to physical RAM via the CPU Memory Management Unit (MMU) and OS page tables.

A process encapsulates:

• Private Virtual Memory Map: Divided into Text (compiled code instructions), Data/BSS (globals/statics), Heap (dynamically allocated memory via malloc or garbage collectors), and Stack segments.
• Kernel Resource Descriptors: File descriptor table (open files, active TCP sockets, pipes), environment variables, working directory, and user security credentials (UID/GID).
• Hard Hardware Isolation: If Process A attempts to read or write to an address belonging to Process B without shared memory mappings, the CPU MMU generates a hardware page fault, triggering the OS to terminate Process A with a SIGSEGV (Segmentation Fault).

Creation Overhead: Spawning an OS process via fork() and exec() requires duplicating or copying page tables (using Copy-on-Write / CoW), allocating kernel control blocks (PCB), and initializing descriptors, typically taking 1 to 5 milliseconds and consuming megabytes of base memory.

A Thread (Lightweight Process or LWP) is the smallest unit of CPU execution schedulable by the OS kernel. Threads live inside an enclosing parent process.

Key Thread Characteristics:

• Shared Memory: All threads inside the same process share the exact same Heap, global static variables, open file descriptors, and socket handles. Any thread can read or modify data created by any other thread in the process simply by dereferencing a memory pointer (0ns overhead).
• Private State: Each thread maintains its own dedicated Stack (for local function variables and call frames), Program Counter (PC), and CPU register set.
• The Crash Risk: Because memory is shared without hardware boundaries, if a single thread encounters an unhandled exception (e.g., dereferencing a null pointer in C++ or an unrecovered panic in Go), it corrupts the shared heap or crashes the entire parent process, taking down all sibling threads instantly.

Large-scale distributed systems choose between multi-process and multi-threaded architectures based on resilience vs memory efficiency:

When independent processes must collaborate, they use kernel-mediated IPC channels:

1. Unix Domain Sockets (UDS): Bidirectional byte/datagram stream on the local filesystem. Bypasses the network TCP/IP stack (no checksums, no routing), achieving sub-microsecond latency. Used between Nginx and Gunicorn/Puma.
2. Anonymous / Named Pipes (FIFOs): Unidirectional data streaming between parent-child or unrelated processes on the same host.
3. Shared Memory (shm_open / mmap): Multiple processes map the same physical RAM pages into their virtual address spaces. Offers the highest possible IPC throughput (GB/s) because data transfers bypass the OS kernel completely, but requires explicit semaphore synchronization.
4. Message Queues (POSIX / System V): Kernel-managed message queues for structured event passing.

import multiprocessing as mp
import threading

# Multi-threaded: Shares memory, but subject to GIL in Python
def thread_worker(shared_list, value):
    shared_list.append(value) # Direct shared memory mutation

# Multi-process: Total memory isolation, requires IPC Queue
def process_worker(ipc_queue, value):
    # Runs in completely separate OS process address space
    ipc_queue.put(value * 2) # Serialized and sent over OS pipe