Chapter 4: Threads Operating System Concepts

Study Notes

Threads are fundamental units of CPU utilization in multithreaded systems, enabling efficient management of multiple tasks.
Modern applications typically operate using multiple threads to enhance performance, allowing concurrent execution of tasks within the same application.

Responsiveness: Enables continuation of execution even when parts of a process are blocked, crucial for user interfaces.
Resource Sharing: Threads utilize the same process resources, simplifying communication compared to shared memory or message passing.
Economy: Threads are cheaper to create and switch than processes, reducing overhead and enhancing performance.
Scalability: Application can scale to utilize multicore architectures effectively, enhancing overall performance.

Programmers face challenges in multicore systems, including activity division, balancing work, data splitting, and managing data dependencies.
Parallelism allows simultaneous task execution, while concurrency enables progress on multiple tasks even on single-core systems.

Data Parallelism: Distributes data subsets across multiple cores, applying the same operation on each.
Task Parallelism: Assigns distinct operations to different threads across the cores.

Describes the potential performance gains when adding more processing cores to applications with both serial and parallel components.
Speedup is limited by the serial portion's size; as more cores are added, the speedup approaches 1 divided by the serial fraction.

User Threads: Managed by user-level libraries, e.g., POSIX Pthreads, Windows threads, Java threads.
Kernel Threads: Directly supported by the operating system, providing better integration with the kernel.

Many-to-One: Multiple user threads map to a single kernel thread; blocking one thread blocks all.
One-to-One: Each user thread corresponds to one kernel thread, allowing greater concurrency.
Many-to-Many: Supports multiple user threads mapped to multiple kernel threads, optimizing kernel thread creation.
Two-level Model: A hybrid that binds user threads to kernel threads.

Provide APIs for thread creation and management, implemented either in user space or kernel space.
Pthreads standard (POSIX) offers specifications for thread synchronization and behavior.

Emerging trend where thread management is handled by compilers and runtime libraries rather than programmers, improving program correctness.
Key methods include thread pools, OpenMP, and Grand Central Dispatch, among others.

Utilize a predefined number of threads that await tasks, enhancing efficiency by reducing the overhead of thread creation.
Useful in applications with variable workloads, allowing for flexible task scheduling.

A set of compiler directives for C, C++, and FORTRAN, supporting parallel programming in shared-memory systems.

Both Windows and Linux provide robust multithreading support through various thread libraries and models, fostering effective application development.