Historically, a process was the fundamental unit of resource allocation and also the fundamental unit of dispatching (CPU scheduling). However, this monolithic view became inefficient for applications that could benefit from internal concurrency. This led to the concept of threads, often referred to as "lightweight processes." A thread is a basic unit of CPU utilization within a process.

Threads offer significant advantages over traditional multi-process approaches for achieving concurrency within an application:

• Responsiveness:
• In a single-threaded process, if a part of the application performs a lengthy or blocking operation (e.g., loading a large file from disk, making a network call, waiting for user input), the entire application freezes and becomes unresponsive.
• With multithreading, if one thread blocks or performs a long operation, other threads within the same process can continue executing, keeping the application responsive to the user. For example, in a web browser, one thread can render a web page while another thread fetches images or videos in the background.
• Resource Sharing:
• Threads within the same process inherently share the same code segment, data segment (global variables), open files, signals, and other operating system resources.
• This shared memory space makes communication and data exchange between threads extremely efficient and fast, typically through shared variables or common data structures, without requiring complex inter-process communication (IPC) mechanisms.
• In contrast, separate processes communicate via more heavyweight IPC methods (e.g., pipes, message queues, shared memory segments), which incur higher overhead.
• Economy (Overhead Reduction):
• Creating a new thread is significantly less expensive (in terms of time and system resources) than creating a new process. This is because threads share the parent process's memory space and most resources, avoiding the need for the OS to allocate a complete new address space, file tables, etc.
• Context switching between threads within the same process is also much faster than context switching between distinct processes.
• This economy makes it feasible to create and manage a large number of threads for fine-grained concurrency.
• Scalability (Utilization of Multi-core/Multi-processor Architectures):
• On systems with multiple CPU cores or multiple processors, multiple threads belonging to the same process can execute truly in parallel on different cores.
• This parallel execution allows applications that are designed to be multithreaded to take full advantage of modern hardware, significantly speeding up complex computations or tasks that can be broken down into independent sub-tasks. A single-threaded process, even on a multi-core machine, can only use one core at a time.

Threads can be implemented at different levels, affecting how they are managed and scheduled:

• User Threads:
• Management: Managed entirely by a user-level thread library (e.g., POSIX Pthreads library for Linux, often implemented entirely in user space). The operating system kernel is completely unaware of the existence of these individual threads. The kernel only sees the containing process as a single unit of execution.
• Scheduling: The user-level thread library manages thread creation, destruction, scheduling (which user thread runs next within the process), and context switching. These operations do not require kernel calls (system calls).
• Advantages: Fast and Efficient: Thread creation, destruction, and context switching are extremely fast because they involve no kernel mode privileges or system call overhead.
• Disadvantages: Blocking System Calls: If one user thread within a process makes a blocking system call (e.g., read() from a slow device), the entire process (and thus all other user threads within that process) will block.
• Kernel Threads:
• Management: Managed directly by the operating system kernel. The kernel is aware of and directly responsible for creating, scheduling, and destroying individual kernel threads.
• Advantages: True Concurrency: Multiple kernel threads from the same process can run concurrently on different CPU cores, enabling genuine parallelism.
• Disadvantages: Higher Overhead: Creating, destroying, and context switching kernel threads involves system calls, which incurs higher overhead compared to user threads.

The relationship between user threads and kernel threads is defined by different multithreading models:

• Many-to-One Model:
• Mapping: Many user-level threads are mapped to a single kernel thread.
• Behavior: All user-level thread management (creation, scheduling, etc.) is handled by the user-level thread library.
• Advantages: Highly efficient for user-level thread management due to no kernel intervention.
• Disadvantages: A single blocking system call by any user thread will block the entire process.
• One-to-One Model:
• Mapping: Each user-level thread is mapped to a separate, distinct kernel thread.
• Advantages: Allows multiple threads to run in parallel on multi-core processors.
• Disadvantages: Increased overhead due to system call requirements for thread management.
• Many-to-Many Model (Hybrid Model):
• Mapping: Multiplexes many user-level threads onto a smaller or equal number of kernel threads.
• Advantages: Scalability and flexibility in mapping user threads to kernel threads.
• Disadvantages: More challenging to implement than the other two models due to coordination requirements.