{"title":"Threads and Processes","description":null,"content":"When you double-click an application on your computer, the operating system creates a **process**. When that application needs to do multiple things at once, like downloading a file while updating the UI, it creates **threads**.\n\nThese two concepts are the foundation of concurrent programming. Every time you write code that runs in parallel, handles multiple requests, or performs background tasks, you're working with threads and processes.\n\nIn this chapter, we'll explore:\n\n- What are processes and threads?\n- Key differences between them\n- How they share (or don't share) memory\n- When to use each\n\n---\n\n# 1. What is a Process?\n\nA **process** is an instance of a running program. When you launch a program, the operating system creates a process to execute it.\n\nEach process has its own:\n\n- **Memory space** (code, data, heap, stack)\n- **System resources** (file handles, network connections)\n- **Process ID (PID)** assigned by the OS\n- **Security context** (user permissions)\n\n Resources\\n\\n style Process fill:#00ceff,stroke:#000,color:#000\\n style Code fill:#ffa94d,stroke:#000,color:#000\\n style Data fill:#ffa94d,stroke:#000,color:#000\\n style Heap fill:#69db7c,stroke:#000,color:#000\\n style Stack fill:#69db7c,stroke:#000,color:#000\\n style Resources fill:#9775fa,stroke:#000,color:#000\\n style FH fill:#38d9a9,stroke:#000,color:#000\\n style Net fill:#38d9a9,stroke:#000,color:#000\\n style Mem fill:#38d9a9,stroke:#000,color:#000\"} -->\n```mermaid\nflowchart TB\n subgraph Process[\"Process (PID: 1234)\"]\n direction TB\n Code[\"Code Segment
(Program Instructions)\"]\n Data[\"Data Segment
(Global Variables)\"]\n Heap[\"Heap
(Dynamic Memory)\"]\n Stack[\"Stack
(Function Calls)\"]\n end\n\n subgraph Resources[\"OS Resources\"]\n FH[\"File Handles\"]\n Net[\"Network Sockets\"]\n Mem[\"Memory Maps\"]\n end\n\n Process --> Resources\n\n style Process fill:#00ceff,stroke:#000,color:#000\n style Code fill:#ffa94d,stroke:#000,color:#000\n style Data fill:#ffa94d,stroke:#000,color:#000\n style Heap fill:#69db7c,stroke:#000,color:#000\n style Stack fill:#69db7c,stroke:#000,color:#000\n style Resources fill:#9775fa,stroke:#000,color:#000\n style FH fill:#38d9a9,stroke:#000,color:#000\n style Net fill:#38d9a9,stroke:#000,color:#000\n style Mem fill:#38d9a9,stroke:#000,color:#000\n```\n\n\nEach process runs in isolation. One process cannot directly access another process's memory.\n\nThis isolation is a feature, not a bug. If your web browser crashes, it should not take down your entire operating system. Process isolation makes this possible.\n\n---\n\n# 2. What is a Thread?\n\nA **thread** is a unit of execution within a process. Every process has at least one thread (the main thread). A process can create additional threads to perform tasks concurrently.\n\nThreads within the same process share:\n\n- **Code segment** (same program instructions)\n- **Data segment** (global variables)\n- **Heap** (dynamically allocated memory)\n- **Open file handles and resources**\n\nBut each thread has its own:\n\n- **Stack** (local variables, function call history)\n- **Program counter** (current instruction being executed)\n- **Registers** (CPU state)\n\n\n```mermaid\nflowchart TB\n subgraph Process[\"Process\"]\n direction TB\n subgraph Shared[\"Shared Memory\"]\n Code[\"Code\"]\n Data[\"Data\"]\n Heap[\"Heap\"]\n end\n\n subgraph T1[\"Thread 1\"]\n S1[\"Stack\"]\n PC1[\"Program Counter\"]\n end\n\n subgraph T2[\"Thread 2\"]\n S2[\"Stack\"]\n PC2[\"Program Counter\"]\n end\n\n subgraph T3[\"Thread 3\"]\n S3[\"Stack\"]\n PC3[\"Program Counter\"]\n end\n end\n\n style Process fill:#00ceff,stroke:#000,color:#000\n style Shared fill:#69db7c,stroke:#000,color:#000\n style Code fill:#ffa94d,stroke:#000,color:#000\n style Data fill:#ffa94d,stroke:#000,color:#000\n style Heap fill:#ffa94d,stroke:#000,color:#000\n style T1 fill:#9775fa,stroke:#000,color:#000\n style T2 fill:#9775fa,stroke:#000,color:#000\n style T3 fill:#9775fa,stroke:#000,color:#000\n style S1 fill:#38d9a9,stroke:#000,color:#000\n style S2 fill:#38d9a9,stroke:#000,color:#000\n style S3 fill:#38d9a9,stroke:#000,color:#000\n style PC1 fill:#38d9a9,stroke:#000,color:#000\n style PC2 fill:#38d9a9,stroke:#000,color:#000\n style PC3 fill:#38d9a9,stroke:#000,color:#000\n```\n\n\nThreads are sometimes called \"lightweight processes\" because they share resources with their parent process rather than having their own copy of everything.\n\n---\n\n# 3. Process vs Thread: Key Differences\n\n\n| Aspect | Process | Thread |\n| Memory | Separate address space | Shared address space |\n| Creation | Slower (allocates new memory) | Faster (shares existing memory) |\n| Communication | IPC mechanisms (pipes, sockets) | Direct shared memory access |\n| Isolation | Full isolation | No isolation within process |\n| Crash impact | Only that process affected | Can crash entire process |\n| Context switch | Expensive (save/restore memory maps) | Cheaper (save/restore registers) |\n\n\n### 3.1 Memory Model\n\nThe fundamental difference is how they handle memory:\n\n\n```mermaid\nflowchart LR\n subgraph OS[\"Operating System\"]\n subgraph P1[\"Process A\"]\n M1[\"Memory Space A\"]\n T1A[\"Thread 1\"]\n T2A[\"Thread 2\"]\n end\n\n subgraph P2[\"Process B\"]\n M2[\"Memory Space B\"]\n T1B[\"Thread 1\"]\n end\n end\n\n T1A -.->|\"Can Access\"| M1\n T2A -.->|\"Can Access\"| M1\n T1B -.->|\"Can Access\"| M2\n\n M1 -.-x|\"Cannot Access\"| M2\n\n style P1 fill:#00ceff,stroke:#000,color:#000\n style P2 fill:#ffa94d,stroke:#000,color:#000\n style M1 fill:#69db7c,stroke:#000,color:#000\n style M2 fill:#69db7c,stroke:#000,color:#000\n style T1A fill:#9775fa,stroke:#000,color:#000\n style T2A fill:#9775fa,stroke:#000,color:#000\n style T1B fill:#9775fa,stroke:#000,color:#000\n```\n\n\nThreads within Process A can freely read and write the same memory. But Process A cannot access Process B's memory without special inter-process communication (IPC) mechanisms.\n\n### 3.2 Creation Overhead\n\nCreating a process involves:\n\n1. Allocating a new address space\n2. Copying or setting up memory mappings\n3. Creating OS data structures\n4. Setting up security context\n\nCreating a thread involves:\n\n1. Allocating a stack\n2. Creating minimal OS data structures\n3. Adding to parent process's thread list\n\nThreads are typically 10-100x faster to create than processes.\n\n### 3.3 Context Switching\n\nWhen the CPU switches from running one execution unit to another, it performs a **context switch**. The cost differs significantly:\n\n**Process context switch:**\n\n- Save CPU registers\n- Save memory management info (page tables)\n- Flush CPU caches (TLB)\n- Load new process's state\n\n**Thread context switch (same process):**\n\n- Save CPU registers\n- Load new thread's state\n- Memory mappings remain the same\n\nThread switches are faster because the memory context stays the same.\n\n---\n\n# 4. Inter-Process Communication (IPC)\n\nSince processes cannot directly access each other's memory, they need special mechanisms to communicate:\n\n|\\\"IPC\\\"| IPC\\n IPC <-->|\\\"IPC\\\"| P2\\n\\n style IPC fill:#69db7c,stroke:#000,color:#000\\n style P1 fill:#00ceff,stroke:#000,color:#000\\n style P2 fill:#ffa94d,stroke:#000,color:#000\\n style Pipes fill:#38d9a9,stroke:#000,color:#000\\n style Sockets fill:#38d9a9,stroke:#000,color:#000\\n style SharedMem fill:#38d9a9,stroke:#000,color:#000\\n style MsgQueue fill:#38d9a9,stroke:#000,color:#000\\n style Files fill:#38d9a9,stroke:#000,color:#000\\n style T1 fill:#9775fa,stroke:#000,color:#000\\n style T2 fill:#9775fa,stroke:#000,color:#000\"} -->\n```mermaid\nflowchart TB\n subgraph IPC[\"Inter-Process Communication Methods\"]\n direction LR\n Pipes[\"Pipes\"]\n Sockets[\"Sockets\"]\n SharedMem[\"Shared Memory\"]\n MsgQueue[\"Message Queues\"]\n Files[\"Files\"]\n end\n\n subgraph P1[\"Process A\"]\n T1[\"Thread\"]\n end\n\n subgraph P2[\"Process B\"]\n T2[\"Thread\"]\n end\n\n P1 <-->|\"IPC\"| IPC\n IPC <-->|\"IPC\"| P2\n\n style IPC fill:#69db7c,stroke:#000,color:#000\n style P1 fill:#00ceff,stroke:#000,color:#000\n style P2 fill:#ffa94d,stroke:#000,color:#000\n style Pipes fill:#38d9a9,stroke:#000,color:#000\n style Sockets fill:#38d9a9,stroke:#000,color:#000\n style SharedMem fill:#38d9a9,stroke:#000,color:#000\n style MsgQueue fill:#38d9a9,stroke:#000,color:#000\n style Files fill:#38d9a9,stroke:#000,color:#000\n style T1 fill:#9775fa,stroke:#000,color:#000\n style T2 fill:#9775fa,stroke:#000,color:#000\n```\n\n\n\n| Method | Description | Use Case |\n\n| Pipes | One-way byte stream | Parent-child communication |\n| Sockets | Network communication | Distributed systems, any two processes |\n| Shared Memory | Memory mapped by multiple processes | High-performance data sharing |\n| Message Queues | OS-managed message buffers | Decoupled communication |\n| Files | Persistent storage | Simple, persistent data exchange |\n\n\nIPC adds overhead compared to thread communication. This is why threads are preferred when tasks need to share data frequently.\n\n---\n\n# 5. When to Use Processes vs Threads\n\n### Use Threads When:\n\n- Tasks need to share data frequently\n- Low latency communication is required\n- You want efficient resource usage\n- Tasks are part of the same application\n\n##### **Examples:**\n\n- Web server handling multiple requests\n- GUI applications (UI thread + background workers)\n- Parallel data processing\n\n### Use Processes When:\n\n- Isolation is critical (one task crashing shouldn't affect others)\n- Running untrusted or third-party code\n- Tasks are independent programs\n- You need to leverage multiple CPU cores with separate memory\n\n##### **Examples:**\n\n- Browser tabs (Chrome uses process per tab)\n- Microservices architecture\n- Running external commands or scripts\n- Worker processes in web servers (like Gunicorn)\n\n---\n\n# 6. Summary\n\n**Processes** and **threads** are the building blocks of concurrent execution:\n\n\n| Concept | Process | Thread |\n| Definition | Running instance of a program | Unit of execution within a process |\n| Memory | Isolated address space | Shared with other threads in same process |\n| Communication | IPC (pipes, sockets, etc.) | Direct memory access |\n| Creation cost | High | Low |\n| Use case | Isolation, separate programs | Parallelism within a program |\n\n\n#### **Key Takeaways:**\n\n1. Processes provide isolation. Threads provide efficiency.\n2. Threads share memory, which is both powerful and dangerous.\n3. Always protect shared data with synchronization.\n4. Use thread pools instead of creating threads directly.\n5. Choose processes when isolation matters more than performance.\n\nUnderstanding these fundamentals is essential for writing concurrent applications and answering system design questions about scalability and performance.","pageType":"lld-interviews"}

Threads and Processes

Ashish Pratap Singh

Get Premium