1. Chapter 4: Threads
READ 4.1 & 4.2
NOT RESPONSIBLE FOR 4.3 & 4.4 1

2. Chapter 4: Threads Overview Multithreading Models Thread Libraries
Threading Issues
Operating System Examples
Windows XP Threads
Linux Threads 2

3. Objectives
To introduce the notion of a thread — a fundamental unit of CPU utilization that forms the basis of multithreaded computer systems
To discuss the APIs for the Pthreads, Win32, and Java thread libraries
To examine issues related to multithreaded programming

4. Single and Multithreaded Processes
LOOK AT MY THREE SLIDES ON PROCESSES VS THREADS, UP THROUGH MY PICTURE SIMILAR TO THIS ONE
(REASON — NO TEXT ON HIS SLIDES, NEXT SLIDE IS ESSENTIALLY USELESS) 4

5. Benefits Responsiveness Resource Sharing Economy Scalability
SIGH…. BACK TO MY “WHY THREADS?” SLIDE 5

6. Multicore Programming
Multicore systems are putting pressure on programmers
Challenges include
Dividing activities
Balance
Data splitting
Data dependency
Testing and debugging

7. Multithreaded Server Architecture

8. Concurrent Execution on a Single-core System

9. Parallel Execution on a Multicore System

10. User Threads Thread management done by user-level threads library
Three primary thread libraries:
POSIX Pthreads
Win32 threads
Java threads
AND AGAIN BACK TO MY SLIDES…
SAME ON NEXT SLIDE…
(HE BARELY MENTIONS THESE TWO NOW, BUT HE USED TO HAVE A FEW PARAGRAPHS ON THIS) 10

11. Kernel Threads Supported by the Kernel Examples Windows XP/2000
Solaris
Linux
Tru64 UNIX
Mac OS X 11

12. Chapter 4: Threads Overview Multithreading Models Thread Libraries
Threading Issues
Operating System Examples
Windows XP Threads
Linux Threads 12

13. Multithreading Models
Many-to-One
One-to-One
Many-to-Many
OK, FINALLY SOMETHING USEFUL! 13

14. Many-to-One Many user-level threads mapped to single kernel thread
Examples:
Solaris Green Threads
GNU Portable Threads
Relate to my slide on “User-Level Threads”
User manages the threads
Entire process blocks if one thread blocks
Only one thread accesses kernel so can’t run multiple threads in parallel on multiprocessor 14

15. Many-to-One Model
Many user-level threads mapped to single kernel thread
Examples:
Solaris Green Threads
GNU Portable Threads 15

16. One-to-One Each user-level thread maps to kernel thread Examples
Windows NT/XP/2000
Linux
Solaris 9 and later
Relate to my slide on “Kernel-Level Threads”
A process can now have multiple kernel-level threads, so when one thread blocks it can switch to another
Multiple threads can run in parallel on a multiprocessor
But creating a single user-level thread has overhead of also creating a kernel thread 16

17. One-to-one Model Each user-level thread maps to kernel thread Examples
Windows NT/XP/2000
Linux
Solaris 9 and later 17

18. Many-to-Many Model
Allows many user level threads to be mapped to many kernel threads
Allows the operating system to create a sufficient number of kernel threads
Solaris prior to version 9
Windows NT/2000 with the ThreadFiber package
User can create multiple threads and manage them, but only one kernel thread runs at a time 18

19. Many-to-Many Model
Allows many user level threads to be mapped to many kernel threads
Allows the operating system to create a sufficient number of kernel threads
Solaris prior to version 9
Windows NT/2000 with the ThreadFiber package 19

20. Two-level Model
Similar to M:M, except that it allows a user thread to be bound to kernel thread
Examples
IRIX
HP-UX
Tru64 UNIX
Solaris 8 and earlier 20

21. Two-level Model
Similar to M:M, except that it allows a user thread to be bound to kernel thread
Examples
IRIX
HP-UX
Tru64 UNIX
Solaris 8 and earlier
THEN BACK TO MY “TWO-LEVEL THREAD MODEL” SLIDE 21

22. Chapter 4: Threads Overview Multithreading Models Thread Libraries
Threading Issues
Operating System Examples
Windows XP Threads
Linux Threads
I’M NOT GOING TO COVER THIS OR HOLD YOU RESPONSIBLE FOR IT, BUT SKIM THE MATERIAL BRIEFLY ANYWAY 22

23. Thread Libraries
A thread library provides programmer with an API for creating and managing threads
Two primary ways of implementing
Library entirely in user space
Kernel-level library supported by the OS
I’M NOT GOING TO COVER THIS OR HOLD YOU RESPONSIBLE FOR IT, BUT SKIM THE MATERIAL BRIEFLY ANYWAY

24. Pthreads May be provided either as user-level or kernel-level
A POSIX standard (IEEE c) API for thread creation and synchronization
API specifies behavior of the thread library, implementation is up to development of the library
Common in UNIX operating systems (Solaris, Linux, Mac OS X)
I’M NOT GOING TO COVER THIS OR HOLD YOU RESPONSIBLE FOR IT, BUT SKIM THE MATERIAL BRIEFLY ANYWAY 24

25. Java Threads Java threads are managed by the JVM
Typically implemented using the threads model provided by underlying OS
Java threads may be created by:
Extending Thread class
Implementing the Runnable interface
I’M NOT GOING TO COVER THIS OR HOLD YOU RESPONSIBLE FOR IT, BUT SKIM THE MATERIAL BRIEFLY ANYWAY 25

26. Chapter 4: Threads Overview Multithreading Models Thread Libraries
Threading Issues
Operating System Examples
Windows XP Threads
Linux Threads
THIS IS MATERIAL THAT I DIDN’T USED TO COVER, SO NOTHING ON THIS IN MY SLIDES 26

27. Threading Issues Semantics of fork() and exec() system calls
Thread cancellation of target thread
Asynchronous or deferred
Signal handling
Thread pools
Thread-specific data
Scheduler activations 27

28. Semantics of fork() and exec()
Does fork() duplicate only the calling thread or all threads?
Most UNIX systems have two versions of fork, on that does each of these
Duplicating only the calling thread is useful if the forked process will then immediately do an exec() 28

29. Thread Cancellation Terminating a thread before it has finished
Two general approaches:
Asynchronous cancellation terminates the target thread immediately
Deferred cancellation allows the target thread to periodically check if it should be cancelled
Multiple threads searching a database, if one finds the result, cancel the others
Close a web page, cancel the threads getting the data over the network (separate threads fetching different images)
Proble is that a thread may be sharing resources or need to update shared data, so asynch cancellation may leave system in an inconsistent state or not free all resources properly 29

30. Signal Handling
Signals are used in UNIX systems to notify a process that a particular event has occurred
A signal handler is used to process signals
Signal is generated by particular event
Signal is delivered to a process
Signal is handled
Signals for errors such as illegal memory access, timer expiration
Signals for user actions such a mouse click, changing window size
Most UNIX systems allow a thread to choose which signals to accept and which to block 30

31. Signal Handling Options for the signal handler:
Deliver the signal to the thread to which the signal applies
Deliver the signal to every thread in the process
Deliver the signal to certain threads in the process
Assign a specific thread to receive all signals for the process

32. Thread Pools
Create a number of threads in a pool where they await work
Advantages:
Usually slightly faster to service a request with an existing thread than create a new thread
Allows the number of threads in the application(s) to be bound to the size of the pool
Set the size of the pool based on number of CPUs, amount of memory, number of expected requests, etc.
Or allow pool size to change dynamically 32

33. Thread Specific Data Allows each thread to have its own copy of data
Useful when you do not have control over the thread creation process (i.e., when using a thread pool)
Allow each worker thread in client-server system to have a separate data area for request-specific data
Most systems support this 33

34. Scheduler Activations
Both M:M and Two-level models require communication to maintain the appropriate number of kernel threads allocated to the application
Scheduler activations provide upcalls - a communication mechanism from the kernel to the thread library
This communication allows an application to maintain the correct number kernel threads
How is this done?
Via a Lightweight Processor (LWP), which looks to the user threads as a virtual processor
When the kernel thread blocks, the LWP blocks, and any user threads on that LWP block
Upcalls let the kernel tell the application about threads blocking (so that thread state can be saved and other threads scheduled) 34

35. Chapter 4: Threads Overview Multithreading Models Thread Libraries
Threading Issues
Operating System Examples
Windows XP Threads
Linux Threads
I’M NOT GOING TO COVER THIS OR HOLD YOU RESPONSIBLE FOR IT, BUT SKIM THE MATERIAL BRIEFLY ANYWAY 35

36. Operating System Examples
Windows XP Threads
Linux Thread 36

37. Chapter 4: Threads Overview Multithreading Models Thread Libraries
Threading Issues
Operating System Examples
Windows XP Threads
Linux Threads 37

38. Windows XP Threads

39. Windows XP Threads Implements the one-to-one mapping, kernel-level
Each thread contains
A thread id
Register set
Separate user and kernel stacks
Private data storage area
The register set, stacks, and private storage area are known as the context of the threads 39

40. Windows XP Threads The primary data structures of a thread include:
ETHREAD (executive thread block)
KTHREAD (kernel thread block)
TEB (thread environment block)

41. Chapter 4: Threads Overview Multithreading Models Thread Libraries
Threading Issues
Operating System Examples
Windows XP Threads
Linux Threads 41

42. Linux Threads

43. Linux Threads Linux refers to them as tasks rather than threads
Thread creation is done through clone() system call
clone() allows a child task to share the address space of the parent task (process) 43

44. End of Chapter 4 44