Multithreading and Process Creation

Thread and Process

• A thread is a path of execution within a process, also known as a lightweight process.
• The idea is to achieve parallelism by dividing processes into multiple threads.
• Threads are the fundamental unit of CPU utilization and are the basis for multithreaded computer systems.
• They run within an application.

Multithreaded Systems

• Most modern applications, including kernels, are multithreaded.
• Process creation is heavy-weight, while thread creation is light-weight.
• Simple code is more efficient in multithreaded systems.
• Multiple tasks can be performed simultaneously, such as updating a display, fetching data, and spell checking.

Benefits of Multithreading

• Responsiveness: allows continued execution if part of a process is blocked, which is important for user interfaces.
• Resource sharing: threads share resources of a process easier than shared memory or message passing.
• Economy: thread creation has lower overhead than context switching.
• Scalability: processes can take advantage of multiprocessor architectures.

Multicore Programming

• Helps create concurrent systems for deployment on multicore processor and multiprocessor systems.
• A single processor with multiple execution cores in one chip.

Challenges of Multithreading

• Dividing activities into threads.
• Balancing the load between threads.
• Data splitting and dependency.
• Testing and debugging.

Parallelism and Concurrency

• Parallelism: performs more than one task simultaneously, executing independent tasks at the same instant of time.
• Concurrency: supports more than one task making progress, with multiple tasks executed in an overlapping time period.
• There are two types of parallelism: data parallelism and task parallelism.

Thread Libraries

• User threads: management is done by a user-level thread library.
• Kernel threads: supported by the kernel of the OS.
• Three primary thread libraries: POSIX/Pthreads, Java Threads, and Win32 Threads.

Multithreading Models

• One to one: each user-level thread maps to a kernel thread.
• Many to one: many user-level threads map to a single kernel thread.
• Many to many: many user-level threads map to many kernel threads.
• Two-level model: similar to many to many, but allows a user thread to be bound to a kernel thread.

Thread Library Implementation

• Two primary ways to implement: library entirely in user space, or kernel-level library supported by the OS.
• PThreads: POSIX Portable Operating System Interface, common in UNIX OS (Solaris, Linux, Mac OS X).
• IEEE 1003.1c: POSIX standard API for creating and synchronizing threads.
• Win32: kernel-level, windows.h.
• Java Threads: managed by the JVM, implemented using the threads provided by the underlying OS.

Creating Threads in Java

• Two methods: derive a new class from a thread class and override its run() method, or define a class and implement a runnable interface.
• Implicit threading: use of libraries or other language support to hide the management of threads, such as OpenMP.

Thread Pools

• Create a number of threads in a pool where they await work.
• Faster to service a request with an existing thread than creating a new thread.
• Allows the number of threads to be bound to the size of the pool.

OpenMP and Grand Central Dispatch

• OpenMP: set of compiler directives for C, C++, or FORTRAN, provides support for parallel programming in shared memory environments.
• Grand Central Dispatch: Apple technology for Mac OS X and iOS Operating Systems, extensions to C, C++, languages, API, and runtime library.

Threading Issues

• Semantics of fork() and exec().
• Signal handling (synchronous and asynchronous).
• Thread cancellation (asynchronous and deferred).
• Thread-local storage: allows each thread to have its own copy of data.
• Scheduler activations: both M:M and two-level models require communication to maintain the appropriate number of kernel threads allocated to the application.

Operating System Examples

• Windows Threads: implements 1 to 1 mapping, kernel-level.
• Linux Threads: refer to them as tasks, created through clone(), with flags controlling behavior.
• struct task_struct points to process data structures (shared or unique).

This quiz covers the concepts of multithreading, process creation, and the differences between threads and processes in computer systems. It also touches on the benefits of multithreading and its implementation in modern applications.