The document provides an overview of threads in operating systems, highlighting multithreading models, APIs for thread libraries like pthreads, win32, and Java, and various threading issues. It elaborates on user and kernel threads, emphasizing the benefits of multithreading such as improved responsiveness and resource sharing, and addresses challenges in multicore programming. Additionally, it covers the implementation of threading libraries and examples from different operating systems like Windows XP and Linux.

1. Threads in Operating
systems

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

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

5. Benefits
 Responsiveness
 Resource Sharing
 Economy
 Scalability

6. Multicore Programming
 Multicore CPU appears as multiple CPUs to OS
 Multithreading makes more efficient use of it

7. Multicore Programming
 Multicore systems putting
pressure on programmers,
challenges include
 Dividing activities
 Balance
 Data splitting
 Data dependency
 Testing and debugging

8. Types of Threads
 User threads
 Running user-level code
 Managed by user process
 Needs kernel thread to run system calls, I/O operations, etc.
 Can only be scheduled on CPU through kernel thread
 Kernel threads
 Running kernel-level code
 Managed by kernel
 Can be scheduled on CPU
 A user process needs both user threads and kernel threads to
run

9. Multithreading Models
 User Threads
 Thread management done by user-level threads library
 Three primary thread libraries:
 POSIX Pthreads
 Win32 threads
 Java threads
 Kernel Threads
 Supported by the Kernel
 Present in practically all OS
 Windows XP/2000
 Solaris
 Linux
 Tru64 UNIX
 Mac OS X
 Relationship between user and kernel threads
 Many-to-One
 One-to-One
 Many-to-Many

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

11. Many-to-One Model

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

13. One-to-one Model

14. Many-to-Many Model
 Allows many user level threads to be mapped to fewer or
equal kernel threads
 Number of kernel threads can vary per system, and per
process
 Allows the operating system to create a sufficient
number of kernel threads
 Windows NT/2000 with the ThreadFiber package

15. Many-to-Many Model

16. Two-level Model
 Variation of Many-to-Many, except that it allows a
user thread to be bound to kernel thread
 Examples
 IRIX
 HP-UX
 Tru64 UNIX
 Solaris 8 and earlier

17. Two-level Model

18. Thread Libraries
 Thread library provides programmer with API for
creating and managing threads
 Two primary ways of implementing
 Library entirely in user space
 Kernel-level library supported by the OS
 We’ll study three implementations
 POSIX Pthread
 Win32
 Java

19. POSIX Pthreads
 POSIX standard (IEEE 1003.1c) defines specifications for an
API for thread creation and synchronization
 API specifies behavior of the thread library, implementation
is up to development of the library
 May be provided either as user-level or kernel-level
 Common in UNIX operating systems (Solaris, Linux, Mac OS
X)
 Implemented in C in pthread.h
 pthread_t
 pthread_attr_t
 pthread_create()
 pthread_join()
 pthread_exit()

20. Win32 Threads
 Very similar to Pthreads
 Function prototypes in windows.h
 CreateThread()
 WaitForSingleObject()
 CloseHandle()
 Implementation in proprietary Microsoft code inside
Windows kernel

21. 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
 run() function is thread’s executable code
 Thread start() function creates thread, calls run()
 Thread exits automatically at the end of run()
public interface Runnable
{ public abstract void run(); }

22. Implicit Threading
 Instead of giving developer control through thread
libraries, have threads handled by compilers and run-time
libraries
 OpenMP
 Compiler directives for C/C++
 Programmer inserts preprocessor tags
 Compiler isolates parallelizable sections and creates as many
threads as there are CPUs
 Grand Central Dispatch
 Apple-specific
 Programmer inserts tags in code (like OpenMP)
 GCD manages POSIX threads, assigns work in three FIFO
priority queues

23. 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

24. Semantics of fork() and
exec()
 Recall: fork() and exec() functions in Unix handle new
processes
 Process creation, replace process code
 When a process has several threads, and one thread
calls these functions, does it affect all threads or just
the calling one?

25. Thread Cancellation
 Terminating a target thread before it has finished
 Two general approaches:
 Asynchronous cancellation terminates the target thread
immediately from another thread
 Deferred cancellation allows the target thread to
periodically check if it should cancel itself

26. Signal Handling
 Signals are used to notify a process that a particular event has
occurred
1. Signal is generated by particular event (typically interrupts)
2. Signal is delivered to a process
3. Signal is handled
 A signal handler is used to process signals
 Default handlers in kernel can be overwritten by user-defined
handler
 How to deliver a process-specific signal in a multithreaded
process?
 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

27. Thread Pools
 So far, we’re creating threads when needed
 Thread creation/termination overhead
 With no maximum thread number, more and more threads can be
created until they exhaust system resources
 Create a number of threads at process creation in a thread
pool, where they await work and return after work is done
 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
 Part of the Win32 API
 QueueUserWorkItem()

28. Thread Specific Data
 One advantage of threads is no duplication of common
process data
 But some threads need thread-specific data
 Data unique to that thread
 Data that did not exist at process creation time
 We need support for thread-specific data
 Included in Pthreads, Win32 and Java

29. Scheduler Activations
 Many-to-Many and Two-Level models have a set of kernel threads
and user threads
 Need to keep a balance in the number of each – for best
performance, should be adjusted dynamically
 Require communication between kernel and thread library
 Systems with these models often put a light-weight process
between kernel thread and user thread, to work as a virtual CPU
for the user
 This allows scheduler activation kernel-process communication
scheme
 Kernel provides a set of LWP to process
 Process schedules its own user threads on LWP
 When a thread waits for an event, the kernel warns the process with
an upcall and allocates a new LWP to process
 Process runs upcall handler on new LWP to save thread state, lose
thread’s LWP, and keeps new LWP to schedule other threads

30. Operating System Examples
 Windows XP Threads
 Linux Thread

31. Windows XP Threads
 Implements the one-to-one mapping, kernel-level
 Each thread contains
 A thread id
 Register set
 Separate user and kernel stacks, for when running in user or
kernel mode
 Private data storage area
 The register set, stacks, and private storage area are
known as the context of the threads
 The primary data structures of a thread include:
 ETHREAD (origin & parent)
 KTHREAD (kernel thread information)
 TEB (user thread information)

32. Windows XP Threads

33. Linux Threads
 Linux does not distinguish between processes and threads, calls them
all tasks
 Task creation is done through clone() system call, with a set of flags
 Each task is represented by a kernel structure task_struct, which
only contains pointers to other data structures instead of storing task
info
 Makes varying levels of sharing between tasks possible