Thread

Thread: Basic unit of CPU utilization.

• Instance of executing portion of a program within a process

Purpose: Threads let us avoid incurring the overhead of creating and managing separate PCBs.

Structure:

• thread ID
• Program counter
• register set
• stack
• code section (shared)
• data section (shared)
• other OS resources (shared)

Example: A word processor may have a thread for getting keystrokes from the user, another for spellcheck, and another for graphics.

TODO Diagram of single and multithreaded process.

Motivation

• Increase efficiency of system.
• Process creation is heavy, thread creation is light.
• Can simplify code.

Today: Jernels and moden applications are generall multithreaded.

Benefits

• Responsiveness: Especially important for UI.
• Resource Sharing: Cheaper than shared memory or message passing.
• Economy: Cheaper that process creation and context-switching.
• Scalability: Can use multiprocessor architectures.

Multithreaded Server Architecture

1. A server listens for requests.
2. When it gets a request, it makes a thread to service it.
3. The server then resumes listening for requests.

Multiprogramming

Multicore systems put pressure on programmars.

Challenges include:

• Dividing activities: Find way to divide things into separate, concurrent tasks.
• Balance: Ensure tasks perform equal work of equal value.
• Data splitting: Data accessed and manipulated by also be divided to run on separate cores.
• Data dependnecy: If one task depends on another, their execution must be syncronized.
• Testing and debugging: Testing and debugging concurrent programs is inherently more difficult.

Concurrency v. Parallelism

Parallelism: System can do more than one task simultaneously.

• aka: Hyperthreading

Concurrency: Supports more than one task making progress.

Types of Parallelism:

Data Parallelism: Split data across multiple cores, same operation on each.

Task Parallelism: Distribute threads across cores. Each thread can do unique operations on same or different data.

Amdal’s Law

Identifies performance gains from adding additional cores to an application that has serial and parallel components.

\text{speedup} \le \frac{1}{ S + \frac{1-S}{N} } \\~\\ \small \textit{where $S$ is serial portion; $N$ is processing cores}

The serial portion has a disproportionate effect on performance.

User and Kernel Threads

User: Supported above the kernel, managed without kernel support

Kernel: Managed directly by the Kernel

All modern operating systems support multithreading.

Multithreading Models

1. Many-to-One: Many user threads and mapped to one kernel thread
2. One-to-One: User threads are mapped directly kernel threads.
   • Many languages do this
3. Many-to-Many:

Many to One

Few systems currently use this model, as one thread blocks the rest.

Examples: Solaris Green Threads Library

One to One

More concurrency. Number of threads per process sometimes restricted due to overhead.

Examples: Windows, Linux

Many to Many

Multiplexes many user-level threads to smaller or equal number of kernel threads.

Examples: Windows with ThreadFiber package

Two-Level

Like many-to-many except a user thread can also be bound to a kernel thread.

• e.g., I want one, dedicated and guaranteed thread

Examples: Tru64 UNIX

Thread Library

Provides programmer with API for creating and managing threads

Two Primary Implementation:

1. Entirely in userspace
2. Supported by kernel

Examples:

• Windows: kernel-level
• Java: typically kernel-level
• Pthread: any

Java Threads

Managed by the JVM

You can create a thread by implementing the Runnable interface.

class Mytask extends SomeOtherClass implements Runnable {
    // ...
}

Note: Don’t extend the Thread class, you’ll lock-out extending anything else!