Download threads

CMSC 421 Spring 2004 Section 0202
Part II: Process Management
Chapter 5
Threads
Contents
 Overview
 Multithreading Models
 Threading Issues
 Pthreads
 Solaris 2 Threads
 Windows 2000 Threads
 Linux Threads
 Java Threads
Operating System Concepts
5.2
Silberschatz, Galvin and Gagne 2002
Lightweight Process and Heavyweight
Process
 Lightweight Process (LWP) or thread
 Basic unit of CPU control
 Typically has private
– Id, PC, register set, stacks, local storage
 Shares OS resources with containing process
– Address space (Code section, data section), open
files, etc
 Heavyweight Process (HWP)
 Single thread
Operating System Concepts
5.3
Silberschatz, Galvin and Gagne 2002
Single and Multithreaded Processes
Operating System Concepts
5.4
Silberschatz, Galvin and Gagne 2002
Benefits
 Responsiveness
 Interactive program responds to user even when some
threads are blocked doing other activities
 Resource Sharing
 Shared address space, etc
 Economy
 Lower overhead in creating and context switching threads
than processes
 context switch is 5 times faster
 Thread creation is 30 times faster
 Utilization of multi-processor architectures
 Multiple threads can run on multiple processors
Operating System Concepts
5.5
Silberschatz, Galvin and Gagne 2002
User Threads
 Thread management done by a user-level threads library
 Kernel is unaware of user-level threads
 User-level threads are faster to create and manage
 However, if a thread is blocked on a system call, the
process is blocked too, and none of its other threads
continues to run
 Examples
- POSIX Pthreads
- Mach C-threads
- Solaris 2 threads
Operating System Concepts
5.6
Silberschatz, Galvin and Gagne 2002
Kernel Threads
 Thread management is supported by the Kernel
 Slower than user threads
 But kernel can schedule another thread when one thread
performs a blocking system call
 Examples
- Windows 95/98/NT/2000
- Solaris
- Tru64 UNIX
- BeOS
- Linux
Operating System Concepts
5.7
Silberschatz, Galvin and Gagne 2002
Multithreading Models
 Three models for implementing threads
 Many-to-One
 One-to-One
 Many-to-Many
Operating System Concepts
5.8
Silberschatz, Galvin and Gagne 2002
Many-to-One Model
Operating System Concepts
5.9
Silberschatz, Galvin and Gagne 2002
Many-to-One
 Many user-level threads are mapped to a single kernel




thread.
Multiple threads CANNOT run in parallel in a
multiprocessor system
A blocked thread blocks its process
Used on systems that do not support kernel threads.
Example
 Solaris 2 Green Threads Library
Operating System Concepts
5.10
Silberschatz, Galvin and Gagne 2002
One-to-one Model
Operating System Concepts
5.11
Silberschatz, Galvin and Gagne 2002
One-to-One
 Each user-level thread maps to kernel thread.
 Can burden OS and slowdown application when many
threads are created (due to kernel overhead)
 Examples
- Windows 95/98/NT/2000
- OS/2
Operating System Concepts
5.12
Silberschatz, Galvin and Gagne 2002
Many-to-Many Model
Operating System Concepts
5.13
Silberschatz, Galvin and Gagne 2002
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, and map user threads to them
 Addresses the shortcomings of the many-to-one and oneto-one models
 Examples
 Solaris 2
 Windows NT/2000 with the ThreadFiber package
Operating System Concepts
5.14
Silberschatz, Galvin and Gagne 2002
Threading Issues
 Semantics of fork() and exec() system calls
 Thread cancellation
 Signal handling
 Thread pools
 Thread specific data
Operating System Concepts
5.15
Silberschatz, Galvin and Gagne 2002
fork() and exec() semantics
 fork()
 Does it duplicate ALL threads of the forking process?
 Two flavors: one that duplicates and one that does not
 Exec()
 Replaces the whole process
 Including all threads (LWPs)
Operating System Concepts
5.16
Silberschatz, Galvin and Gagne 2002
Thread Cancellation
 Canceling a target thread
 Asynchronous cancellation (immediate termination)
 Deferred cancellation
 Target thread periodically checks if it should terminate
 Issues:
 reclaiming resources of cancelled target thread
 Shared resources with other threads
 Cancellation points
Operating System Concepts
5.17
Silberschatz, Galvin and Gagne 2002
Signal Handling
 Signal => Notify the process of the occurrence of a
certain event
 Types of signals
 Synchronous
 Delivered to the same process that generated the signal
 Illegal memory access, division by zero, overflow
 Asynchronous
 Generally, delivered to a different process than the one
generating the signal
 <control><C>, timer expiry
 Signals handled using
 Default signal handler (run by the kernel)
 User-defined signal handler
Operating System Concepts
5.18
Silberschatz, Galvin and Gagne 2002
Signal Handling (Cont.)
 Options for delivering signals (depending on signal)
 Only to the thread that generated the signal
 To all threads of a process
 To all threads not blocking the signal
 To a specific/dedicated thread
 Threads many choose to block certain signals
Operating System Concepts
5.19
Silberschatz, Galvin and Gagne 2002
Thread Pools and Thread-specific Data
 Thread pools
 Creating a large number of threads in a system can exhaust
system resources
 Allocate a pool of thread’s
 Allocate available threads from the thread pool to a new
“thread”
 Reduces thread creation time when a request arrives
 Thread-specific data
 Need for supporting private storage for threads that need to
manage their own private data
Operating System Concepts
5.20
Silberschatz, Galvin and Gagne 2002
Pthreads
 a POSIX standard (IEEE 1003.1c) API for thread creation,
synchronization, and management
 API specifies behavior of the thread library,
implementation is up to development of the library.
 Common in UNIX operating systems
Operating System Concepts
5.21
Silberschatz, Galvin and Gagne 2002
Solaris 2 Threads
 Implements the Pthread API + support for user and kernel
threads
 Uses LWP to multiplex user threads
 Implements many-to-many model




LWP reside in kernel space
Allocates a kernel thread to each LWP
User threads can be bound to a LWP or can be unbound
Each user thread contains
 Thread ID, register set (PC and stack pointer), stack, , and
priority
 Each LWP contains
 Register set for running user thread, stack, memory, and
accounting info
Operating System Concepts
5.22
Silberschatz, Galvin and Gagne 2002
Solaris 2 Threads
Operating System Concepts
5.23
Silberschatz, Galvin and Gagne 2002
Solaris Process
Operating System Concepts
5.24
Silberschatz, Galvin and Gagne 2002
Pthreads Example
#include <pthread.h>
#include <stdio.h>
int sum = 0; /* shared data of the threads */
void *runner(void *p);
int main(int argc, char *argv[]) {
pthread_attr_t attr;
pthread_t tid;
pthread_attr_init(&attr);
pthread_create(&tid, &attr, runner, argv[1]); /* create a thread and exec runner*/
pthread_join(tid, NULL);
/* wait for thread to finish exec */
printf(“%d\n”, sum);
exit(0);
}
void *runner(void *param) {
int n = 0, i;
n = atoi(param);
sum = 0;
for(i=0; i;<n; i++) sum += i;
pthread_exit(0);
}
Operating System Concepts
5.25
Silberschatz, Galvin and Gagne 2002
Windows 2000 Threads
 Implements the one-to-one mapping.
 Each thread contains
- a thread id
- register set
- separate user and kernel stacks
- private data storage area
Operating System Concepts
5.26
Silberschatz, Galvin and Gagne 2002
Linux Threads
 Thread creation is done through clone() system call
 Linux’s trick
 Store process information in separate structures and use
pointers to point to them instead of storing it directly in the
data structure for the process
 Clone() allows a child task to share the address space of
the parent task (process)
 Linux refers to them as tasks rather than threads.
Operating System Concepts
5.27
Silberschatz, Galvin and Gagne 2002
Java Threads
 Java threads may be created by:
 Extending Thread class
 Implementing the Runnable interface
 Java threads are managed by the JVM.
 Java thread implementation depends on how the JVM is
implemented on the host OS
 Can be one-to-one for JVMs on Windows 2000 etc systems
 Can be many-tone on Solaris 2 green thread JVM systems
Operating System Concepts
5.28
Silberschatz, Galvin and Gagne 2002
Java Thread Example
class Summation extends Thread {
private int bound = 0;
public Summation(int n) {
bound = n;
}
public void run() {
int sum = 0;
for(int I=0; I<bound; I++)
sum += I;
System.out.println(“Sum = “ + sum);
}
}
public class Test {
public static void main(String[] args) {
Summation thr = new Summation(Integer.parseInt(args[0]);
thr.start();
}
}
Operating System Concepts
5.29
Silberschatz, Galvin and Gagne 2002
Java Thread States
Operating System Concepts
5.30
Silberschatz, Galvin and Gagne 2002