WEEK 10 Networks and Operating Systems - Process Management: Threads

CS2005 Networks and Operating Systems

  • Process management: Threads

  • Authors: A. Silberschatz, P. Baer Galvin and G. Gagne ©2003

Session Objectives

  • Introduce the notion of a thread as a fundamental unit of CPU utilization.

  • Discuss APIs for the Java thread library.

Key Questions

  • What is the difference between concurrency and parallelism?

  • What are threads, how are they used, and what are their benefits?

  • What is the lifecycle of a thread in Java?

Execution Models

Sequential Execution

  • Only one task or subtask (job, process) runs at a time.

  • Must complete before another task starts.

Concurrent Execution

  • Multiple tasks appear to run simultaneously.

  • Utilizes CPU time-slicing.

  • Involves process states where one task runs and another waits.

Parallel Execution

  • Multiple tasks run simultaneously on multiple CPUs/cores.

  • Requires hardware support for true parallelism.

Examples of Execution

Sequential Execution Example

  • Tasks executed one after the other, e.g., Task 1 runs then Task 2.

Concurrent Execution Example

  • Tasks interleave execution, e.g., Task 1 might run, then Task 2 when Task 1 is waiting.

Parallel Execution Example

  • Tasks executed simultaneously on different CPUs, e.g., Task 1 and Task 2 running at the same time.

Parallel Concurrent Execution

  • Combination of parallel and concurrent execution methods.

Concurrency vs. Parallelism

Definitions

  • Concurrency: Tasks start, run, and complete in overlapping time.

  • Parallelism: Tasks run at the same time on multiple CPUs/cores.

Key Points

  • Applications can be neither parallel nor concurrent (e.g., sequential processing).

  • Applications can also be parallel but not concurrent or concurrent but not parallel.

What is a Thread?

  • A thread is the smallest unit of CPU utilization.

  • Consists of: thread ID, program counter, register set, and stack.

  • Shares code section, data section, and resources with other threads in the same process.

  • Examples include web browsers and word processors that handle various tasks in separate threads.

Single-threaded vs. Multithreaded Process

  • Single-threaded: Only one thread of execution.

  • Multithreaded: Multiple threads allow concurrent execution within the same memory space.

Benefits of Threads

  • Responsiveness: Multithreading allows programs to remain responsive even when part of them is blocked.

  • Resource Sharing: Threads share the memory and resources of their parent process.

  • Economy: Thread creation is more resource-efficient than process creation.

  • Scalability: Multithreading enhances performance in multiprocessor architectures by executing threads in parallel.

Multithreaded Server Architecture

  • A single-threaded server handles one client request at a time.

  • Multithreaded servers create new threads for each client request, improving concurrency.

Extra: Multicore Programming

  • Development evolution led to systems with multiple CPU cores.

  • Multithreaded programming enhances concurrency and performance in multicore systems.

Speedup – Amdahl’s Law

  • Describes potential performance gains from adding cores to applications with both serial and parallel components.

  • Formula: speedup ≤ 1 / (S + (1 - S) / N)(Where S is the serial portion and N is the number of cores.)

Challenges in Multicore Programming

  • Identifying tasks: Applications must be divided into independent, concurrent tasks.

  • Load balancing: Ensuring tasks are evenly distributed across processors.

  • Data splitting: Managing data dependencies among tasks to prevent errors.

  • Testing and debugging: Complexity increases significantly with parallel execution.

Thread Programming in Java

  • Ways to create threads:

    1. By extending the Thread class.

    2. By implementing the Runnable interface.

Java Threads Lifecycle

  • States: NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING, TERMINATED.

  • Transitions between states depend on thread actions and other threads' statuses.

Key States

  • NEW: Thread created but not started.

  • RUNNABLE: Active in execution.

  • BLOCKED: Waiting for a monitor lock.

  • WAITING: Waiting indefinitely for a specific action.

  • TIMED_WAITING: Waiting with a specified timeout.

  • TERMINATED: Thread completed or terminated.

Recap

  • Multithreading maximizes CPU utilization through simultaneous execution of threads, sharing of memory, and lightweight processes.

Creating (Invoking) a Thread

  • Two methods to create threads:

    1. Extending the Thread class (with built-in thread functionality).

    2. Implementing the Runnable interface (allowing class extensions).

Extending the java.lang.Thread Class

  • Override run() method in the class extending Thread.

  • Use the start() method to begin thread execution.

Java Threads States

  • Understand states like NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING, TERMINATED to manage threads efficiently.

Session Objectives (Recap)

  • Understanding threads' role, benefits, and lifecycle within Java's concurrency model is crucial for effective programming.