Threads vs Process

• Modern applications are multithreaded and perform multiple tasks within the same application by using separate threads.
• Kernel is also multithreaded.
• A thread runs within a process.
• Thread creation is lightweight whereas process creation is heavyweight.
• Threads simply code and increase efficiency.
• A thread is a path of execution within a process; a process can contain multiple threads.
• Threads are the basic unit of CPU utilization or execution.
• A thread comprises: a thread ID, a Program counter, a Register set, and a Stack
• A thread within a process can share its code, data section, and OS resources with other threads within the process.

Threads vs. Process

• Threads within a process run in a shared memory space; processes run in separate memory spaces.
• Threads share code and data sections, and OS resources, with other threads within the process.
• A process does not share its parts.
• Threads have their own ID, Program counter, register set, and stack.

User Threads vs. Kernel Threads

• User threads: Management is done by user-level threads library.
• Main user thread libraries include: POSIX Pthreads (Linux & Unix), Windows threads, and Java threads.
• Kernel threads: Supported directly by the kernel (OS).
• Examples of OSs with kernel threads include: Windows, Linux, Solaris, and macOS.
• For user threads and kernel threads to interact, they must have a relationship or a model between them.
• Three possible types of models: Many-to-One, One-to-One, and Many-to-Many.

Multithreading Models

• Many-to-One: Many user-level threads connect to a single kernel thread.
• Disadvantages: If one thread is blocked, all will be blocked; multithreads cannot run in parallel on a multicore processor.
• Example systems include: Solaris Green threads and GNU Portable threads.
• One-to-One: Each user-level thread has a corresponding individual kernel thread.
• Creating a user-level thread creates a kernel thread.
• Advantages: More concurrency than the Many-to-One model.
• Disadvantage: There can be restrictions on the number of threads per process due to overhead.
• Example systems include: Windows, Linux, and Solaris 9 and later.
• Many-to-Many: Allows many user-level threads to map to many kernel threads.
• Example systems include: Solaris 9 and prior, and Windows thread fiber packages.
• The OS allows creating a sufficient amount of kernel threads.
• Two-Level Model: Allows user-level threads to be bound to kernel threads.
• The user-level thread is assigned to a kernel thread, and this relationship is maintained throughout execution.
• Example systems include: Solaris 8 and earlier, IRIX, and HP-UX.

Why Multithreading?

• A thread is sometimes called a light weight process.
• A process with multiple threads can perform multiple tasks at the same time.
• Multiple threads allows browsers to perform multiple tasks simultaneously.
• Can achieve parallelism by dividing process into multiple threads, each thread executing its part of code at a time.
• Multithreaded processes have multiple threads, and each executes a part of the code at a time in parallel compared to single threaded.

Benefits of Multithreading

• Responsiveness: Continues execution even if a process is blocked or performing a lengthy operation, which is useful for user interfaces.
• Resource Sharing: Threads share the memory and resources of a process by default, which is easier than message passing and shared memory.
• Economy: Allocating memory and resources to a process is more expensive than creating threads, which have low overhead. Switching threads is faster than context switching in processes
• Scalability: Threads can run in parallel on different processors, which makes jobs faster and scalable.

Thread Libraries

• Thread libraries provide programmers with APIs to create and manage threads.
• Two ways to implement libraries: Entirely in user space, or kernel-level library supported by the OS.
• User-space implementation is faster but may lack access to low-level functionalities and require kernel support.

Types of Threads

• Pthreads: A POSIX standard API used for creation and synchronization of threads
• It's a specification, not an implementation e.g. the API specifies thread library behaviour, but implementation is library developer's responsibility
• Java Threads: Managed by the Java Virtual Machine (JVM), implemented using the underlying OS's thread model.
• Java threads can be created by extending the Thread class or implementing the Runnable interface.

Multicore Programming

• Multicore or multiprocessor systems put pressure on programmers, leading to challenges like: Dividing activities, balance, data splitting, data dependency and testing & debugging
• Parallelism is a system that can perform more than one task simultaneously, whereas concurrency is a system that supports more than one task making progress.

Types of Parallelism

• Data parallelism distributes subsets of the same data across multiple cores, performing the same operation on each.
• Task parallelism distributes threads across cores, with each thread performing a unique operation.
• The number of threads grows as the architectural support for threading increases.
• CPUs have cores and hardware threads ex. Oracle has 8 cores and 8 hardware threads per core.

Concurrency

• Concurrency on a single-core system can be provided in user-level and kernel-level.
• Single core system supports more than one task in progress, but takes more time.

OS Thread Examples

• Windows Threads: Implemented using the Windows API (primary API) and implements one-to-one mapping and in Kernel-level.
• Java Threads: Java threads can be created in 2 ways: Extending the {@code Thread} class; implementing the {@code Runnable} interface
• The Windows thread contains: Thread ID, Register set to represent the state of processor, A separate stack for user and kernel modes for when it runs in user or kernel mode, Private data storage area used by runtime libraries.
• Primary data structures of Windows threads are: ETHREAD (Executive thread block), KTHREAD (Kernel thread block), and TEB (Thread Environment Block).
• The ETHREAD has a pointer that points to the process the thread belongs to and the KTHREAD in kernel space.
• The KTHREAD has scheduling and synchronization information, kernel mode, and a pointer to TEB in user space.
• The TEB contains the thread ID, user mode stack, thread local storage and is in user space.
• Clone() System call allows child task to share address space with parent task (process).
• The clone flags includes that clone FS (file system info is shared), clone VM (same memory space is shared), clone-SIGHAN (signal handlers is shared) and clone-FILES (open files is shared)
• Struct Task structs points to process data structures (shared or unique).
• The KTHREAD has scheduling and synchronization information, kernel mode, and a pointer to TEB in kernel space.
• Linux Thread refers to threads as tasks and uses the clone() system call to create threads
• Java threads can be created in 2 ways: Extending the thread class, Implementing the runnable interface.