Single And Multi Thread Application

Single-Threaded vs Multi-Threaded Applications

Single Thread

• Definition: The program runs with only one thread of execution.
• How it works: Only one task can be performed at a time. The CPU switches between tasks, but only one is actually running at any moment.
• Example:
  • A simple Python script that reads a file, processes it, and then writes the result—all steps happen one after another.
• Analogy:
  • Like a single cashier at a store: customers (tasks) must wait in line and are served one at a time.

Multi Thread

• Definition: The program can run multiple threads of execution at the same time.
• How it works: Multiple tasks can be performed "concurrently" (at the same time, or at least appear to be). Threads share the same memory space.
• Example:
  • A web server that handles multiple client requests at once, with each request handled by a different thread.
• Analogy:
  • Like several cashiers at a store: multiple customers (tasks) can be served at the same time, so the line moves faster.

---

Key Differences Table

Feature	Single Threaded	Multi Threaded
Execution	One task at a time	Multiple tasks at the same time
Performance	Can be slower for many tasks	Can be faster for I/O-bound tasks
Complexity	Simple to write and debug	More complex (need to manage threads)
Use Cases	Simple scripts, CLI tools	Web servers, real-time apps

---

CPU Core Usage

CPU Cores: The Basics

• A CPU core is like a separate "brain" in your computer's processor.
• Modern CPUs have multiple cores (e.g., 2, 4, 8, 16, or more).
• Each core can run one thread at a time independently.

Single-Threaded Programs & CPU Cores

• A single-threaded program can only use one CPU core at a time, no matter how many cores your CPU has.
• Even if your computer has 8 cores, a single-threaded program will only ever fully utilize one of them; the others remain mostly idle for that program.

Multi-Threaded Programs & CPU Cores

• A multi-threaded program can use multiple CPU cores—if the threads are truly running in parallel.
• Each thread can be scheduled to run on a different core, so the program can do more work at the same time.
• This is especially effective for CPU-bound tasks (tasks that require a lot of computation).

Python's Special Case

• In CPython (the standard Python interpreter), the GIL (Global Interpreter Lock) means only one thread can execute Python bytecode at a time, so multi-threaded Python programs don't fully utilize multiple cores for CPU-bound tasks.
• For I/O-bound tasks (like waiting for files or network), threads can still help, because while one thread waits, another can run.
• For true multi-core CPU usage in Python, use multi-processing (multiple processes), not just threads.

Visual Analogy

• Single-threaded: One worker (thread) using one desk (core), even if there are many empty desks.
• Multi-threaded: Many workers (threads), each at their own desk (core), working at the same time.

Summary Table

Program Type	CPU Core Usage
Single-threaded	Only one core
Multi-threaded	Can use multiple cores (if no GIL)
Multi-processing	Can use multiple cores

---

Language Examples

Single-Threaded Languages (by default)

• JavaScript (Node.js):
  • Node.js runs JavaScript in a single thread by default.
  • It uses an event loop and asynchronous callbacks to handle many tasks efficiently, but only one thread executes JavaScript code at a time.
  • Example:

    // Node.js is single-threaded by default
    console.log("Hello, world!");
• Python (with default CPython interpreter):
  • Python can use threads, but due to the GIL, only one thread executes Python bytecode at a time.
  • For most scripts, Python behaves as single-threaded.
  • Example:

    print("Hello, world!")  # Single-threaded execution

Multi-Threaded Languages (or with built-in support)

• Java:
  • Java has strong built-in support for multi-threading.
  • Example:

    class MyThread extends Thread {
        public void run() {
            System.out.println("Thread running");
        }
    }
    public class Main {
        public static void main(String[] args) {
            MyThread t1 = new MyThread();
            t1.start(); // Runs in a new thread
        }
    }
• C++:
  • C++11 and later have standard threading support.
  • Example:

    #include <thread>
    #include <iostream>
    void task() {
        std::cout << "Thread running" << std::endl;
    }
    int main() {
        std::thread t(task);
        t.join();
        return 0;
    }
• Go:
  • Go is designed for concurrency and makes it easy to run code in parallel using goroutines.
  • Example:

    package main
    import (
        "fmt"
        "time"
    )
    func main() {
        go func() {
            fmt.Println("Goroutine running")
        }()
        time.Sleep(time.Second)
    }

Summary Table

Language	Single-threaded by default	Multi-threaded support
JavaScript	Yes (Node.js)	No (but can use worker threads)
Python	Yes (CPython)	Yes (limited by GIL)
Java	No	Yes
C++	No	Yes
Go	No	Yes (via goroutines)
Rust	No	Yes

---

In summary:

• Single-threaded: One thing at a time, simple, but can be slow for many tasks.
• Multi-threaded: Many things at once, faster for I/O-bound tasks, but more complex to manage.
• Single-threaded = one core.
• Multi-threaded = can use many cores (unless limited by language/runtime, like Python's GIL).
• Multi-processing = always uses multiple cores.