Date post: | 26-Mar-2015 |
Category: |
Documents |
Upload: | jessica-maldonado |
View: | 219 times |
Download: | 0 times |
Operating Systems Theory - Threads 1
Operating Systems Theory
Threads
IFE - Computer Science
Alexi Akl
Operating Systems Theory - Threads 2
Contents
Threads and Processes Single And MultiThreaded Processes MultiThreading Models Threading Issues PThreads Windows XP Threads Linux Threads Java Threads
Operating Systems Theory - Threads 3
Threads And Processes
Thread In computer science is short for a thread of execution
Threads are a way for a program to split itself into two or more simultaneously (or pseudo-simultaneously) running tasks
Threads and processes differ from one operating system to another but in general the way that a thread is created and shares its resources is different from the way a process does
Operating Systems Theory - Threads 4
Threads And Processes
A process is the heaviest unit of kernel scheduling Processes own resources allocated by the operating system Resources include memory file handles sockets device handles and windows
A thread is the lightest unit of kernel scheduling At least one thread exists within each process If multiple threads can exist within a process then they share the same memory and file resources
Operating Systems Theory - Threads 5
Single And MultiThreaded Processes
Multiple threads can be executed in parallel on many computer systems This multithreading generally occurs by time slicing wherein a single processor switches between different threads in which case the processing is not literally simultaneous for the single processor is only really doing one thing at a time
Standard PC nowadays has only one processor if it is equipped with more than one processor then different threads and processes can rum literally simultaneously on different processors
Operating Systems Theory - Threads 6
Single And MultiThreaded Processes
Operating Systems Theory - Threads 7
MutiThreaded Processes Benefits
Responsiveness Resource Sharing Economy Utilization of MultiThreaded Processes
architecture
Operating Systems Theory - Threads 8
User-level and Kernel Threads
Three primary User-level thread libraries POSIX Pthreads Win32 threads Java threads
Examples of supported kernel threads Windows XP Solaris Linux Tru64 UNIX Mac OS X
Operating Systems Theory - Threads 9
MutiThreading Models - Many to one
1 Many user level threads mapped to single kernel thread
Examples
1 Solaris Green Threads
2 GNU Portable Threads
Operating Systems Theory - Threads 10
MutiThreading Models - One to one
1 Each user-level thread maps to kernel thread
Examples
1 Windows NTXP2000
2 Linux
3 Solaris 9 and later
Operating Systems Theory - Threads 11
MutiThreading Models ndash Many to many
1 Allows many user level threads to be mapped to many kernel threads
2 Allows the operating system to create a sufficient number of kernel threads
Examples
1 Solaris prior to version 9
2 Windows NT2000 with the ThreadFiber package
Operating Systems Theory - Threads 12
MultiThreading Models - Two Level Model
Similar to bdquoMany to Manyrdquo except that it allows a user thread to be bound to kernel thread
Examples IRIX HP-UX Tru64 UNIX Solaris 8 and earlier
Operating Systems Theory - Threads 13
Threading Issues ndash Thread Cancellation
Thread cancellation Terminating a thread before it has finished has two approaches Asynchronous cancellation terminates the
target thread immediately Deferred cancellation allows the target thread
to periodically check if it should be cancelled
Operating Systems Theory - Threads 14
Threading Issues ndash 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
Options 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
Operating Systems Theory - Threads 15
Threading Issues - Thread Pool
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
Operating Systems Theory - Threads 16
Threading Issues ndash 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 (ie when using a thread pool)
Operating Systems Theory - Threads 17
Threading Issues ndash Scheduler Activations
Both MM 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
Operating Systems Theory - Threads 18
PThreads Historically hardware vendors have implemented their own
proprietary versions of threads These implementations differed substantially from each other making it difficult for programmers to develop portable threaded applications
In order to take full advantage of the capabilities provided by threads a standardized programming interface was required For UNIX systems this interface has been specified by the IEEE POSIX 10031c standard (1995) Implementations which adhere to this standard are referred to as POSIX threads or Pthreads
Pthreads are defined as a set of C language programming types and procedure calls implemented with a pthreadh headerinclude file and a thread library
Common in Unix
Operating Systems Theory - Threads 19
Windows XP Threads
Implements the one-to-one mapping Each thread contains
1048698A thread id 1048698Register set 1048698Separate user and kernel stacks 1048698Private 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 1048698ETHREAD (executive thread block) 1048698KTHREAD (kernel thread block) 1048698TEB (thread environment block)
Operating Systems Theory - Threads 20
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)
Operating Systems Theory - Threads 21
Linux Threads Thread operations include thread creation termination synchronization
(joinsblocking) scheduling data management and process interaction A thread does not maintain a list of created threads nor does it know the thread
that created it All threads within a process share the same address space Threads in the same process share
Process instructions Most data open files (descriptors) signals and signal handlers current working directory User and group id
Each thread has a unique Thread ID set of registers stack pointer stack for local variables return addresses signal mask priority Return value errno
pthread functions return 0 if OK
Operating Systems Theory - Threads 22
Linux Threadsinclude ltstdiohgt include ltstdlibhgt include ltpthreadhgt
void print_message_function( void ptr ) char message message = (char ) ptr printf(s n message)
main()pthread_t thread1 thread2char message1 = Thread 1char message2 = Thread 2int iret1 iret2
iret1 = pthread_create( ampthread1 NULL print_message_function (void) message1)iret2 = pthread_create( ampthread2 NULL print_message_function (void) message2)
pthread_join( thread1 NULL)pthread_join( thread2 NULL)
printf(Thread 1 returns dniret1)printf(Thread 2 returns dniret2)exit(0)
Operating Systems Theory - Threads 23
Linux Threads
Output Thread 1 Thread 2 Thread 1 returns 0 Thread 2 returns 0
Threads terminate by explicitly calling pthread_exit by letting the function return or by a call to the function exit which will terminate the process including any threads
Operating Systems Theory - Threads 24
Java Threads
Java threads are managed by the JVM Java threads may be created by
1048698Extending Thread class 1048698Implementing the Runnable interface
Operating Systems Theory - Threads 25
Java Threads Every thread has a priority Threads with higher priority are executed in
preference to threads with lower priority Each thread may or may not also be marked as a daemon When code running in some thread creates a new Thread object the new thread has its priority initially set equal to the priority of the creating thread and is a daemon thread if and only if the creating thread is a daemon
When a Java Virtual Machine starts up there is usually a single non-daemon thread (which typically calls the method named main of some designated class) The Java Virtual Machine continues to execute threads until either of the following occurs The exit method of class Runtime has been called and the security
manager has permitted the exit operation to take place All threads that are not daemon threads have died either by returning
from the call to the run method or by throwing an exception that propagates beyond the run method
There are two ways to create a new thread of execution One is to declare a class to be a subclass of Thread This subclass should override the run method of class Thread An instance of the subclass can then be allocated and started
Operating Systems Theory - Threads 26
Questions
Thank you for your attention
Any questions
Operating Systems Theory - Threads 2
Contents
Threads and Processes Single And MultiThreaded Processes MultiThreading Models Threading Issues PThreads Windows XP Threads Linux Threads Java Threads
Operating Systems Theory - Threads 3
Threads And Processes
Thread In computer science is short for a thread of execution
Threads are a way for a program to split itself into two or more simultaneously (or pseudo-simultaneously) running tasks
Threads and processes differ from one operating system to another but in general the way that a thread is created and shares its resources is different from the way a process does
Operating Systems Theory - Threads 4
Threads And Processes
A process is the heaviest unit of kernel scheduling Processes own resources allocated by the operating system Resources include memory file handles sockets device handles and windows
A thread is the lightest unit of kernel scheduling At least one thread exists within each process If multiple threads can exist within a process then they share the same memory and file resources
Operating Systems Theory - Threads 5
Single And MultiThreaded Processes
Multiple threads can be executed in parallel on many computer systems This multithreading generally occurs by time slicing wherein a single processor switches between different threads in which case the processing is not literally simultaneous for the single processor is only really doing one thing at a time
Standard PC nowadays has only one processor if it is equipped with more than one processor then different threads and processes can rum literally simultaneously on different processors
Operating Systems Theory - Threads 6
Single And MultiThreaded Processes
Operating Systems Theory - Threads 7
MutiThreaded Processes Benefits
Responsiveness Resource Sharing Economy Utilization of MultiThreaded Processes
architecture
Operating Systems Theory - Threads 8
User-level and Kernel Threads
Three primary User-level thread libraries POSIX Pthreads Win32 threads Java threads
Examples of supported kernel threads Windows XP Solaris Linux Tru64 UNIX Mac OS X
Operating Systems Theory - Threads 9
MutiThreading Models - Many to one
1 Many user level threads mapped to single kernel thread
Examples
1 Solaris Green Threads
2 GNU Portable Threads
Operating Systems Theory - Threads 10
MutiThreading Models - One to one
1 Each user-level thread maps to kernel thread
Examples
1 Windows NTXP2000
2 Linux
3 Solaris 9 and later
Operating Systems Theory - Threads 11
MutiThreading Models ndash Many to many
1 Allows many user level threads to be mapped to many kernel threads
2 Allows the operating system to create a sufficient number of kernel threads
Examples
1 Solaris prior to version 9
2 Windows NT2000 with the ThreadFiber package
Operating Systems Theory - Threads 12
MultiThreading Models - Two Level Model
Similar to bdquoMany to Manyrdquo except that it allows a user thread to be bound to kernel thread
Examples IRIX HP-UX Tru64 UNIX Solaris 8 and earlier
Operating Systems Theory - Threads 13
Threading Issues ndash Thread Cancellation
Thread cancellation Terminating a thread before it has finished has two approaches Asynchronous cancellation terminates the
target thread immediately Deferred cancellation allows the target thread
to periodically check if it should be cancelled
Operating Systems Theory - Threads 14
Threading Issues ndash 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
Options 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
Operating Systems Theory - Threads 15
Threading Issues - Thread Pool
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
Operating Systems Theory - Threads 16
Threading Issues ndash 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 (ie when using a thread pool)
Operating Systems Theory - Threads 17
Threading Issues ndash Scheduler Activations
Both MM 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
Operating Systems Theory - Threads 18
PThreads Historically hardware vendors have implemented their own
proprietary versions of threads These implementations differed substantially from each other making it difficult for programmers to develop portable threaded applications
In order to take full advantage of the capabilities provided by threads a standardized programming interface was required For UNIX systems this interface has been specified by the IEEE POSIX 10031c standard (1995) Implementations which adhere to this standard are referred to as POSIX threads or Pthreads
Pthreads are defined as a set of C language programming types and procedure calls implemented with a pthreadh headerinclude file and a thread library
Common in Unix
Operating Systems Theory - Threads 19
Windows XP Threads
Implements the one-to-one mapping Each thread contains
1048698A thread id 1048698Register set 1048698Separate user and kernel stacks 1048698Private 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 1048698ETHREAD (executive thread block) 1048698KTHREAD (kernel thread block) 1048698TEB (thread environment block)
Operating Systems Theory - Threads 20
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)
Operating Systems Theory - Threads 21
Linux Threads Thread operations include thread creation termination synchronization
(joinsblocking) scheduling data management and process interaction A thread does not maintain a list of created threads nor does it know the thread
that created it All threads within a process share the same address space Threads in the same process share
Process instructions Most data open files (descriptors) signals and signal handlers current working directory User and group id
Each thread has a unique Thread ID set of registers stack pointer stack for local variables return addresses signal mask priority Return value errno
pthread functions return 0 if OK
Operating Systems Theory - Threads 22
Linux Threadsinclude ltstdiohgt include ltstdlibhgt include ltpthreadhgt
void print_message_function( void ptr ) char message message = (char ) ptr printf(s n message)
main()pthread_t thread1 thread2char message1 = Thread 1char message2 = Thread 2int iret1 iret2
iret1 = pthread_create( ampthread1 NULL print_message_function (void) message1)iret2 = pthread_create( ampthread2 NULL print_message_function (void) message2)
pthread_join( thread1 NULL)pthread_join( thread2 NULL)
printf(Thread 1 returns dniret1)printf(Thread 2 returns dniret2)exit(0)
Operating Systems Theory - Threads 23
Linux Threads
Output Thread 1 Thread 2 Thread 1 returns 0 Thread 2 returns 0
Threads terminate by explicitly calling pthread_exit by letting the function return or by a call to the function exit which will terminate the process including any threads
Operating Systems Theory - Threads 24
Java Threads
Java threads are managed by the JVM Java threads may be created by
1048698Extending Thread class 1048698Implementing the Runnable interface
Operating Systems Theory - Threads 25
Java Threads Every thread has a priority Threads with higher priority are executed in
preference to threads with lower priority Each thread may or may not also be marked as a daemon When code running in some thread creates a new Thread object the new thread has its priority initially set equal to the priority of the creating thread and is a daemon thread if and only if the creating thread is a daemon
When a Java Virtual Machine starts up there is usually a single non-daemon thread (which typically calls the method named main of some designated class) The Java Virtual Machine continues to execute threads until either of the following occurs The exit method of class Runtime has been called and the security
manager has permitted the exit operation to take place All threads that are not daemon threads have died either by returning
from the call to the run method or by throwing an exception that propagates beyond the run method
There are two ways to create a new thread of execution One is to declare a class to be a subclass of Thread This subclass should override the run method of class Thread An instance of the subclass can then be allocated and started
Operating Systems Theory - Threads 26
Questions
Thank you for your attention
Any questions
Operating Systems Theory - Threads 3
Threads And Processes
Thread In computer science is short for a thread of execution
Threads are a way for a program to split itself into two or more simultaneously (or pseudo-simultaneously) running tasks
Threads and processes differ from one operating system to another but in general the way that a thread is created and shares its resources is different from the way a process does
Operating Systems Theory - Threads 4
Threads And Processes
A process is the heaviest unit of kernel scheduling Processes own resources allocated by the operating system Resources include memory file handles sockets device handles and windows
A thread is the lightest unit of kernel scheduling At least one thread exists within each process If multiple threads can exist within a process then they share the same memory and file resources
Operating Systems Theory - Threads 5
Single And MultiThreaded Processes
Multiple threads can be executed in parallel on many computer systems This multithreading generally occurs by time slicing wherein a single processor switches between different threads in which case the processing is not literally simultaneous for the single processor is only really doing one thing at a time
Standard PC nowadays has only one processor if it is equipped with more than one processor then different threads and processes can rum literally simultaneously on different processors
Operating Systems Theory - Threads 6
Single And MultiThreaded Processes
Operating Systems Theory - Threads 7
MutiThreaded Processes Benefits
Responsiveness Resource Sharing Economy Utilization of MultiThreaded Processes
architecture
Operating Systems Theory - Threads 8
User-level and Kernel Threads
Three primary User-level thread libraries POSIX Pthreads Win32 threads Java threads
Examples of supported kernel threads Windows XP Solaris Linux Tru64 UNIX Mac OS X
Operating Systems Theory - Threads 9
MutiThreading Models - Many to one
1 Many user level threads mapped to single kernel thread
Examples
1 Solaris Green Threads
2 GNU Portable Threads
Operating Systems Theory - Threads 10
MutiThreading Models - One to one
1 Each user-level thread maps to kernel thread
Examples
1 Windows NTXP2000
2 Linux
3 Solaris 9 and later
Operating Systems Theory - Threads 11
MutiThreading Models ndash Many to many
1 Allows many user level threads to be mapped to many kernel threads
2 Allows the operating system to create a sufficient number of kernel threads
Examples
1 Solaris prior to version 9
2 Windows NT2000 with the ThreadFiber package
Operating Systems Theory - Threads 12
MultiThreading Models - Two Level Model
Similar to bdquoMany to Manyrdquo except that it allows a user thread to be bound to kernel thread
Examples IRIX HP-UX Tru64 UNIX Solaris 8 and earlier
Operating Systems Theory - Threads 13
Threading Issues ndash Thread Cancellation
Thread cancellation Terminating a thread before it has finished has two approaches Asynchronous cancellation terminates the
target thread immediately Deferred cancellation allows the target thread
to periodically check if it should be cancelled
Operating Systems Theory - Threads 14
Threading Issues ndash 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
Options 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
Operating Systems Theory - Threads 15
Threading Issues - Thread Pool
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
Operating Systems Theory - Threads 16
Threading Issues ndash 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 (ie when using a thread pool)
Operating Systems Theory - Threads 17
Threading Issues ndash Scheduler Activations
Both MM 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
Operating Systems Theory - Threads 18
PThreads Historically hardware vendors have implemented their own
proprietary versions of threads These implementations differed substantially from each other making it difficult for programmers to develop portable threaded applications
In order to take full advantage of the capabilities provided by threads a standardized programming interface was required For UNIX systems this interface has been specified by the IEEE POSIX 10031c standard (1995) Implementations which adhere to this standard are referred to as POSIX threads or Pthreads
Pthreads are defined as a set of C language programming types and procedure calls implemented with a pthreadh headerinclude file and a thread library
Common in Unix
Operating Systems Theory - Threads 19
Windows XP Threads
Implements the one-to-one mapping Each thread contains
1048698A thread id 1048698Register set 1048698Separate user and kernel stacks 1048698Private 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 1048698ETHREAD (executive thread block) 1048698KTHREAD (kernel thread block) 1048698TEB (thread environment block)
Operating Systems Theory - Threads 20
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)
Operating Systems Theory - Threads 21
Linux Threads Thread operations include thread creation termination synchronization
(joinsblocking) scheduling data management and process interaction A thread does not maintain a list of created threads nor does it know the thread
that created it All threads within a process share the same address space Threads in the same process share
Process instructions Most data open files (descriptors) signals and signal handlers current working directory User and group id
Each thread has a unique Thread ID set of registers stack pointer stack for local variables return addresses signal mask priority Return value errno
pthread functions return 0 if OK
Operating Systems Theory - Threads 22
Linux Threadsinclude ltstdiohgt include ltstdlibhgt include ltpthreadhgt
void print_message_function( void ptr ) char message message = (char ) ptr printf(s n message)
main()pthread_t thread1 thread2char message1 = Thread 1char message2 = Thread 2int iret1 iret2
iret1 = pthread_create( ampthread1 NULL print_message_function (void) message1)iret2 = pthread_create( ampthread2 NULL print_message_function (void) message2)
pthread_join( thread1 NULL)pthread_join( thread2 NULL)
printf(Thread 1 returns dniret1)printf(Thread 2 returns dniret2)exit(0)
Operating Systems Theory - Threads 23
Linux Threads
Output Thread 1 Thread 2 Thread 1 returns 0 Thread 2 returns 0
Threads terminate by explicitly calling pthread_exit by letting the function return or by a call to the function exit which will terminate the process including any threads
Operating Systems Theory - Threads 24
Java Threads
Java threads are managed by the JVM Java threads may be created by
1048698Extending Thread class 1048698Implementing the Runnable interface
Operating Systems Theory - Threads 25
Java Threads Every thread has a priority Threads with higher priority are executed in
preference to threads with lower priority Each thread may or may not also be marked as a daemon When code running in some thread creates a new Thread object the new thread has its priority initially set equal to the priority of the creating thread and is a daemon thread if and only if the creating thread is a daemon
When a Java Virtual Machine starts up there is usually a single non-daemon thread (which typically calls the method named main of some designated class) The Java Virtual Machine continues to execute threads until either of the following occurs The exit method of class Runtime has been called and the security
manager has permitted the exit operation to take place All threads that are not daemon threads have died either by returning
from the call to the run method or by throwing an exception that propagates beyond the run method
There are two ways to create a new thread of execution One is to declare a class to be a subclass of Thread This subclass should override the run method of class Thread An instance of the subclass can then be allocated and started
Operating Systems Theory - Threads 26
Questions
Thank you for your attention
Any questions
Operating Systems Theory - Threads 4
Threads And Processes
A process is the heaviest unit of kernel scheduling Processes own resources allocated by the operating system Resources include memory file handles sockets device handles and windows
A thread is the lightest unit of kernel scheduling At least one thread exists within each process If multiple threads can exist within a process then they share the same memory and file resources
Operating Systems Theory - Threads 5
Single And MultiThreaded Processes
Multiple threads can be executed in parallel on many computer systems This multithreading generally occurs by time slicing wherein a single processor switches between different threads in which case the processing is not literally simultaneous for the single processor is only really doing one thing at a time
Standard PC nowadays has only one processor if it is equipped with more than one processor then different threads and processes can rum literally simultaneously on different processors
Operating Systems Theory - Threads 6
Single And MultiThreaded Processes
Operating Systems Theory - Threads 7
MutiThreaded Processes Benefits
Responsiveness Resource Sharing Economy Utilization of MultiThreaded Processes
architecture
Operating Systems Theory - Threads 8
User-level and Kernel Threads
Three primary User-level thread libraries POSIX Pthreads Win32 threads Java threads
Examples of supported kernel threads Windows XP Solaris Linux Tru64 UNIX Mac OS X
Operating Systems Theory - Threads 9
MutiThreading Models - Many to one
1 Many user level threads mapped to single kernel thread
Examples
1 Solaris Green Threads
2 GNU Portable Threads
Operating Systems Theory - Threads 10
MutiThreading Models - One to one
1 Each user-level thread maps to kernel thread
Examples
1 Windows NTXP2000
2 Linux
3 Solaris 9 and later
Operating Systems Theory - Threads 11
MutiThreading Models ndash Many to many
1 Allows many user level threads to be mapped to many kernel threads
2 Allows the operating system to create a sufficient number of kernel threads
Examples
1 Solaris prior to version 9
2 Windows NT2000 with the ThreadFiber package
Operating Systems Theory - Threads 12
MultiThreading Models - Two Level Model
Similar to bdquoMany to Manyrdquo except that it allows a user thread to be bound to kernel thread
Examples IRIX HP-UX Tru64 UNIX Solaris 8 and earlier
Operating Systems Theory - Threads 13
Threading Issues ndash Thread Cancellation
Thread cancellation Terminating a thread before it has finished has two approaches Asynchronous cancellation terminates the
target thread immediately Deferred cancellation allows the target thread
to periodically check if it should be cancelled
Operating Systems Theory - Threads 14
Threading Issues ndash 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
Options 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
Operating Systems Theory - Threads 15
Threading Issues - Thread Pool
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
Operating Systems Theory - Threads 16
Threading Issues ndash 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 (ie when using a thread pool)
Operating Systems Theory - Threads 17
Threading Issues ndash Scheduler Activations
Both MM 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
Operating Systems Theory - Threads 18
PThreads Historically hardware vendors have implemented their own
proprietary versions of threads These implementations differed substantially from each other making it difficult for programmers to develop portable threaded applications
In order to take full advantage of the capabilities provided by threads a standardized programming interface was required For UNIX systems this interface has been specified by the IEEE POSIX 10031c standard (1995) Implementations which adhere to this standard are referred to as POSIX threads or Pthreads
Pthreads are defined as a set of C language programming types and procedure calls implemented with a pthreadh headerinclude file and a thread library
Common in Unix
Operating Systems Theory - Threads 19
Windows XP Threads
Implements the one-to-one mapping Each thread contains
1048698A thread id 1048698Register set 1048698Separate user and kernel stacks 1048698Private 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 1048698ETHREAD (executive thread block) 1048698KTHREAD (kernel thread block) 1048698TEB (thread environment block)
Operating Systems Theory - Threads 20
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)
Operating Systems Theory - Threads 21
Linux Threads Thread operations include thread creation termination synchronization
(joinsblocking) scheduling data management and process interaction A thread does not maintain a list of created threads nor does it know the thread
that created it All threads within a process share the same address space Threads in the same process share
Process instructions Most data open files (descriptors) signals and signal handlers current working directory User and group id
Each thread has a unique Thread ID set of registers stack pointer stack for local variables return addresses signal mask priority Return value errno
pthread functions return 0 if OK
Operating Systems Theory - Threads 22
Linux Threadsinclude ltstdiohgt include ltstdlibhgt include ltpthreadhgt
void print_message_function( void ptr ) char message message = (char ) ptr printf(s n message)
main()pthread_t thread1 thread2char message1 = Thread 1char message2 = Thread 2int iret1 iret2
iret1 = pthread_create( ampthread1 NULL print_message_function (void) message1)iret2 = pthread_create( ampthread2 NULL print_message_function (void) message2)
pthread_join( thread1 NULL)pthread_join( thread2 NULL)
printf(Thread 1 returns dniret1)printf(Thread 2 returns dniret2)exit(0)
Operating Systems Theory - Threads 23
Linux Threads
Output Thread 1 Thread 2 Thread 1 returns 0 Thread 2 returns 0
Threads terminate by explicitly calling pthread_exit by letting the function return or by a call to the function exit which will terminate the process including any threads
Operating Systems Theory - Threads 24
Java Threads
Java threads are managed by the JVM Java threads may be created by
1048698Extending Thread class 1048698Implementing the Runnable interface
Operating Systems Theory - Threads 25
Java Threads Every thread has a priority Threads with higher priority are executed in
preference to threads with lower priority Each thread may or may not also be marked as a daemon When code running in some thread creates a new Thread object the new thread has its priority initially set equal to the priority of the creating thread and is a daemon thread if and only if the creating thread is a daemon
When a Java Virtual Machine starts up there is usually a single non-daemon thread (which typically calls the method named main of some designated class) The Java Virtual Machine continues to execute threads until either of the following occurs The exit method of class Runtime has been called and the security
manager has permitted the exit operation to take place All threads that are not daemon threads have died either by returning
from the call to the run method or by throwing an exception that propagates beyond the run method
There are two ways to create a new thread of execution One is to declare a class to be a subclass of Thread This subclass should override the run method of class Thread An instance of the subclass can then be allocated and started
Operating Systems Theory - Threads 26
Questions
Thank you for your attention
Any questions
Operating Systems Theory - Threads 5
Single And MultiThreaded Processes
Multiple threads can be executed in parallel on many computer systems This multithreading generally occurs by time slicing wherein a single processor switches between different threads in which case the processing is not literally simultaneous for the single processor is only really doing one thing at a time
Standard PC nowadays has only one processor if it is equipped with more than one processor then different threads and processes can rum literally simultaneously on different processors
Operating Systems Theory - Threads 6
Single And MultiThreaded Processes
Operating Systems Theory - Threads 7
MutiThreaded Processes Benefits
Responsiveness Resource Sharing Economy Utilization of MultiThreaded Processes
architecture
Operating Systems Theory - Threads 8
User-level and Kernel Threads
Three primary User-level thread libraries POSIX Pthreads Win32 threads Java threads
Examples of supported kernel threads Windows XP Solaris Linux Tru64 UNIX Mac OS X
Operating Systems Theory - Threads 9
MutiThreading Models - Many to one
1 Many user level threads mapped to single kernel thread
Examples
1 Solaris Green Threads
2 GNU Portable Threads
Operating Systems Theory - Threads 10
MutiThreading Models - One to one
1 Each user-level thread maps to kernel thread
Examples
1 Windows NTXP2000
2 Linux
3 Solaris 9 and later
Operating Systems Theory - Threads 11
MutiThreading Models ndash Many to many
1 Allows many user level threads to be mapped to many kernel threads
2 Allows the operating system to create a sufficient number of kernel threads
Examples
1 Solaris prior to version 9
2 Windows NT2000 with the ThreadFiber package
Operating Systems Theory - Threads 12
MultiThreading Models - Two Level Model
Similar to bdquoMany to Manyrdquo except that it allows a user thread to be bound to kernel thread
Examples IRIX HP-UX Tru64 UNIX Solaris 8 and earlier
Operating Systems Theory - Threads 13
Threading Issues ndash Thread Cancellation
Thread cancellation Terminating a thread before it has finished has two approaches Asynchronous cancellation terminates the
target thread immediately Deferred cancellation allows the target thread
to periodically check if it should be cancelled
Operating Systems Theory - Threads 14
Threading Issues ndash 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
Options 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
Operating Systems Theory - Threads 15
Threading Issues - Thread Pool
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
Operating Systems Theory - Threads 16
Threading Issues ndash 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 (ie when using a thread pool)
Operating Systems Theory - Threads 17
Threading Issues ndash Scheduler Activations
Both MM 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
Operating Systems Theory - Threads 18
PThreads Historically hardware vendors have implemented their own
proprietary versions of threads These implementations differed substantially from each other making it difficult for programmers to develop portable threaded applications
In order to take full advantage of the capabilities provided by threads a standardized programming interface was required For UNIX systems this interface has been specified by the IEEE POSIX 10031c standard (1995) Implementations which adhere to this standard are referred to as POSIX threads or Pthreads
Pthreads are defined as a set of C language programming types and procedure calls implemented with a pthreadh headerinclude file and a thread library
Common in Unix
Operating Systems Theory - Threads 19
Windows XP Threads
Implements the one-to-one mapping Each thread contains
1048698A thread id 1048698Register set 1048698Separate user and kernel stacks 1048698Private 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 1048698ETHREAD (executive thread block) 1048698KTHREAD (kernel thread block) 1048698TEB (thread environment block)
Operating Systems Theory - Threads 20
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)
Operating Systems Theory - Threads 21
Linux Threads Thread operations include thread creation termination synchronization
(joinsblocking) scheduling data management and process interaction A thread does not maintain a list of created threads nor does it know the thread
that created it All threads within a process share the same address space Threads in the same process share
Process instructions Most data open files (descriptors) signals and signal handlers current working directory User and group id
Each thread has a unique Thread ID set of registers stack pointer stack for local variables return addresses signal mask priority Return value errno
pthread functions return 0 if OK
Operating Systems Theory - Threads 22
Linux Threadsinclude ltstdiohgt include ltstdlibhgt include ltpthreadhgt
void print_message_function( void ptr ) char message message = (char ) ptr printf(s n message)
main()pthread_t thread1 thread2char message1 = Thread 1char message2 = Thread 2int iret1 iret2
iret1 = pthread_create( ampthread1 NULL print_message_function (void) message1)iret2 = pthread_create( ampthread2 NULL print_message_function (void) message2)
pthread_join( thread1 NULL)pthread_join( thread2 NULL)
printf(Thread 1 returns dniret1)printf(Thread 2 returns dniret2)exit(0)
Operating Systems Theory - Threads 23
Linux Threads
Output Thread 1 Thread 2 Thread 1 returns 0 Thread 2 returns 0
Threads terminate by explicitly calling pthread_exit by letting the function return or by a call to the function exit which will terminate the process including any threads
Operating Systems Theory - Threads 24
Java Threads
Java threads are managed by the JVM Java threads may be created by
1048698Extending Thread class 1048698Implementing the Runnable interface
Operating Systems Theory - Threads 25
Java Threads Every thread has a priority Threads with higher priority are executed in
preference to threads with lower priority Each thread may or may not also be marked as a daemon When code running in some thread creates a new Thread object the new thread has its priority initially set equal to the priority of the creating thread and is a daemon thread if and only if the creating thread is a daemon
When a Java Virtual Machine starts up there is usually a single non-daemon thread (which typically calls the method named main of some designated class) The Java Virtual Machine continues to execute threads until either of the following occurs The exit method of class Runtime has been called and the security
manager has permitted the exit operation to take place All threads that are not daemon threads have died either by returning
from the call to the run method or by throwing an exception that propagates beyond the run method
There are two ways to create a new thread of execution One is to declare a class to be a subclass of Thread This subclass should override the run method of class Thread An instance of the subclass can then be allocated and started
Operating Systems Theory - Threads 26
Questions
Thank you for your attention
Any questions
Operating Systems Theory - Threads 6
Single And MultiThreaded Processes
Operating Systems Theory - Threads 7
MutiThreaded Processes Benefits
Responsiveness Resource Sharing Economy Utilization of MultiThreaded Processes
architecture
Operating Systems Theory - Threads 8
User-level and Kernel Threads
Three primary User-level thread libraries POSIX Pthreads Win32 threads Java threads
Examples of supported kernel threads Windows XP Solaris Linux Tru64 UNIX Mac OS X
Operating Systems Theory - Threads 9
MutiThreading Models - Many to one
1 Many user level threads mapped to single kernel thread
Examples
1 Solaris Green Threads
2 GNU Portable Threads
Operating Systems Theory - Threads 10
MutiThreading Models - One to one
1 Each user-level thread maps to kernel thread
Examples
1 Windows NTXP2000
2 Linux
3 Solaris 9 and later
Operating Systems Theory - Threads 11
MutiThreading Models ndash Many to many
1 Allows many user level threads to be mapped to many kernel threads
2 Allows the operating system to create a sufficient number of kernel threads
Examples
1 Solaris prior to version 9
2 Windows NT2000 with the ThreadFiber package
Operating Systems Theory - Threads 12
MultiThreading Models - Two Level Model
Similar to bdquoMany to Manyrdquo except that it allows a user thread to be bound to kernel thread
Examples IRIX HP-UX Tru64 UNIX Solaris 8 and earlier
Operating Systems Theory - Threads 13
Threading Issues ndash Thread Cancellation
Thread cancellation Terminating a thread before it has finished has two approaches Asynchronous cancellation terminates the
target thread immediately Deferred cancellation allows the target thread
to periodically check if it should be cancelled
Operating Systems Theory - Threads 14
Threading Issues ndash 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
Options 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
Operating Systems Theory - Threads 15
Threading Issues - Thread Pool
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
Operating Systems Theory - Threads 16
Threading Issues ndash 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 (ie when using a thread pool)
Operating Systems Theory - Threads 17
Threading Issues ndash Scheduler Activations
Both MM 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
Operating Systems Theory - Threads 18
PThreads Historically hardware vendors have implemented their own
proprietary versions of threads These implementations differed substantially from each other making it difficult for programmers to develop portable threaded applications
In order to take full advantage of the capabilities provided by threads a standardized programming interface was required For UNIX systems this interface has been specified by the IEEE POSIX 10031c standard (1995) Implementations which adhere to this standard are referred to as POSIX threads or Pthreads
Pthreads are defined as a set of C language programming types and procedure calls implemented with a pthreadh headerinclude file and a thread library
Common in Unix
Operating Systems Theory - Threads 19
Windows XP Threads
Implements the one-to-one mapping Each thread contains
1048698A thread id 1048698Register set 1048698Separate user and kernel stacks 1048698Private 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 1048698ETHREAD (executive thread block) 1048698KTHREAD (kernel thread block) 1048698TEB (thread environment block)
Operating Systems Theory - Threads 20
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)
Operating Systems Theory - Threads 21
Linux Threads Thread operations include thread creation termination synchronization
(joinsblocking) scheduling data management and process interaction A thread does not maintain a list of created threads nor does it know the thread
that created it All threads within a process share the same address space Threads in the same process share
Process instructions Most data open files (descriptors) signals and signal handlers current working directory User and group id
Each thread has a unique Thread ID set of registers stack pointer stack for local variables return addresses signal mask priority Return value errno
pthread functions return 0 if OK
Operating Systems Theory - Threads 22
Linux Threadsinclude ltstdiohgt include ltstdlibhgt include ltpthreadhgt
void print_message_function( void ptr ) char message message = (char ) ptr printf(s n message)
main()pthread_t thread1 thread2char message1 = Thread 1char message2 = Thread 2int iret1 iret2
iret1 = pthread_create( ampthread1 NULL print_message_function (void) message1)iret2 = pthread_create( ampthread2 NULL print_message_function (void) message2)
pthread_join( thread1 NULL)pthread_join( thread2 NULL)
printf(Thread 1 returns dniret1)printf(Thread 2 returns dniret2)exit(0)
Operating Systems Theory - Threads 23
Linux Threads
Output Thread 1 Thread 2 Thread 1 returns 0 Thread 2 returns 0
Threads terminate by explicitly calling pthread_exit by letting the function return or by a call to the function exit which will terminate the process including any threads
Operating Systems Theory - Threads 24
Java Threads
Java threads are managed by the JVM Java threads may be created by
1048698Extending Thread class 1048698Implementing the Runnable interface
Operating Systems Theory - Threads 25
Java Threads Every thread has a priority Threads with higher priority are executed in
preference to threads with lower priority Each thread may or may not also be marked as a daemon When code running in some thread creates a new Thread object the new thread has its priority initially set equal to the priority of the creating thread and is a daemon thread if and only if the creating thread is a daemon
When a Java Virtual Machine starts up there is usually a single non-daemon thread (which typically calls the method named main of some designated class) The Java Virtual Machine continues to execute threads until either of the following occurs The exit method of class Runtime has been called and the security
manager has permitted the exit operation to take place All threads that are not daemon threads have died either by returning
from the call to the run method or by throwing an exception that propagates beyond the run method
There are two ways to create a new thread of execution One is to declare a class to be a subclass of Thread This subclass should override the run method of class Thread An instance of the subclass can then be allocated and started
Operating Systems Theory - Threads 26
Questions
Thank you for your attention
Any questions
Operating Systems Theory - Threads 7
MutiThreaded Processes Benefits
Responsiveness Resource Sharing Economy Utilization of MultiThreaded Processes
architecture
Operating Systems Theory - Threads 8
User-level and Kernel Threads
Three primary User-level thread libraries POSIX Pthreads Win32 threads Java threads
Examples of supported kernel threads Windows XP Solaris Linux Tru64 UNIX Mac OS X
Operating Systems Theory - Threads 9
MutiThreading Models - Many to one
1 Many user level threads mapped to single kernel thread
Examples
1 Solaris Green Threads
2 GNU Portable Threads
Operating Systems Theory - Threads 10
MutiThreading Models - One to one
1 Each user-level thread maps to kernel thread
Examples
1 Windows NTXP2000
2 Linux
3 Solaris 9 and later
Operating Systems Theory - Threads 11
MutiThreading Models ndash Many to many
1 Allows many user level threads to be mapped to many kernel threads
2 Allows the operating system to create a sufficient number of kernel threads
Examples
1 Solaris prior to version 9
2 Windows NT2000 with the ThreadFiber package
Operating Systems Theory - Threads 12
MultiThreading Models - Two Level Model
Similar to bdquoMany to Manyrdquo except that it allows a user thread to be bound to kernel thread
Examples IRIX HP-UX Tru64 UNIX Solaris 8 and earlier
Operating Systems Theory - Threads 13
Threading Issues ndash Thread Cancellation
Thread cancellation Terminating a thread before it has finished has two approaches Asynchronous cancellation terminates the
target thread immediately Deferred cancellation allows the target thread
to periodically check if it should be cancelled
Operating Systems Theory - Threads 14
Threading Issues ndash 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
Options 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
Operating Systems Theory - Threads 15
Threading Issues - Thread Pool
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
Operating Systems Theory - Threads 16
Threading Issues ndash 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 (ie when using a thread pool)
Operating Systems Theory - Threads 17
Threading Issues ndash Scheduler Activations
Both MM 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
Operating Systems Theory - Threads 18
PThreads Historically hardware vendors have implemented their own
proprietary versions of threads These implementations differed substantially from each other making it difficult for programmers to develop portable threaded applications
In order to take full advantage of the capabilities provided by threads a standardized programming interface was required For UNIX systems this interface has been specified by the IEEE POSIX 10031c standard (1995) Implementations which adhere to this standard are referred to as POSIX threads or Pthreads
Pthreads are defined as a set of C language programming types and procedure calls implemented with a pthreadh headerinclude file and a thread library
Common in Unix
Operating Systems Theory - Threads 19
Windows XP Threads
Implements the one-to-one mapping Each thread contains
1048698A thread id 1048698Register set 1048698Separate user and kernel stacks 1048698Private 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 1048698ETHREAD (executive thread block) 1048698KTHREAD (kernel thread block) 1048698TEB (thread environment block)
Operating Systems Theory - Threads 20
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)
Operating Systems Theory - Threads 21
Linux Threads Thread operations include thread creation termination synchronization
(joinsblocking) scheduling data management and process interaction A thread does not maintain a list of created threads nor does it know the thread
that created it All threads within a process share the same address space Threads in the same process share
Process instructions Most data open files (descriptors) signals and signal handlers current working directory User and group id
Each thread has a unique Thread ID set of registers stack pointer stack for local variables return addresses signal mask priority Return value errno
pthread functions return 0 if OK
Operating Systems Theory - Threads 22
Linux Threadsinclude ltstdiohgt include ltstdlibhgt include ltpthreadhgt
void print_message_function( void ptr ) char message message = (char ) ptr printf(s n message)
main()pthread_t thread1 thread2char message1 = Thread 1char message2 = Thread 2int iret1 iret2
iret1 = pthread_create( ampthread1 NULL print_message_function (void) message1)iret2 = pthread_create( ampthread2 NULL print_message_function (void) message2)
pthread_join( thread1 NULL)pthread_join( thread2 NULL)
printf(Thread 1 returns dniret1)printf(Thread 2 returns dniret2)exit(0)
Operating Systems Theory - Threads 23
Linux Threads
Output Thread 1 Thread 2 Thread 1 returns 0 Thread 2 returns 0
Threads terminate by explicitly calling pthread_exit by letting the function return or by a call to the function exit which will terminate the process including any threads
Operating Systems Theory - Threads 24
Java Threads
Java threads are managed by the JVM Java threads may be created by
1048698Extending Thread class 1048698Implementing the Runnable interface
Operating Systems Theory - Threads 25
Java Threads Every thread has a priority Threads with higher priority are executed in
preference to threads with lower priority Each thread may or may not also be marked as a daemon When code running in some thread creates a new Thread object the new thread has its priority initially set equal to the priority of the creating thread and is a daemon thread if and only if the creating thread is a daemon
When a Java Virtual Machine starts up there is usually a single non-daemon thread (which typically calls the method named main of some designated class) The Java Virtual Machine continues to execute threads until either of the following occurs The exit method of class Runtime has been called and the security
manager has permitted the exit operation to take place All threads that are not daemon threads have died either by returning
from the call to the run method or by throwing an exception that propagates beyond the run method
There are two ways to create a new thread of execution One is to declare a class to be a subclass of Thread This subclass should override the run method of class Thread An instance of the subclass can then be allocated and started
Operating Systems Theory - Threads 26
Questions
Thank you for your attention
Any questions
Operating Systems Theory - Threads 8
User-level and Kernel Threads
Three primary User-level thread libraries POSIX Pthreads Win32 threads Java threads
Examples of supported kernel threads Windows XP Solaris Linux Tru64 UNIX Mac OS X
Operating Systems Theory - Threads 9
MutiThreading Models - Many to one
1 Many user level threads mapped to single kernel thread
Examples
1 Solaris Green Threads
2 GNU Portable Threads
Operating Systems Theory - Threads 10
MutiThreading Models - One to one
1 Each user-level thread maps to kernel thread
Examples
1 Windows NTXP2000
2 Linux
3 Solaris 9 and later
Operating Systems Theory - Threads 11
MutiThreading Models ndash Many to many
1 Allows many user level threads to be mapped to many kernel threads
2 Allows the operating system to create a sufficient number of kernel threads
Examples
1 Solaris prior to version 9
2 Windows NT2000 with the ThreadFiber package
Operating Systems Theory - Threads 12
MultiThreading Models - Two Level Model
Similar to bdquoMany to Manyrdquo except that it allows a user thread to be bound to kernel thread
Examples IRIX HP-UX Tru64 UNIX Solaris 8 and earlier
Operating Systems Theory - Threads 13
Threading Issues ndash Thread Cancellation
Thread cancellation Terminating a thread before it has finished has two approaches Asynchronous cancellation terminates the
target thread immediately Deferred cancellation allows the target thread
to periodically check if it should be cancelled
Operating Systems Theory - Threads 14
Threading Issues ndash 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
Options 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
Operating Systems Theory - Threads 15
Threading Issues - Thread Pool
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
Operating Systems Theory - Threads 16
Threading Issues ndash 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 (ie when using a thread pool)
Operating Systems Theory - Threads 17
Threading Issues ndash Scheduler Activations
Both MM 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
Operating Systems Theory - Threads 18
PThreads Historically hardware vendors have implemented their own
proprietary versions of threads These implementations differed substantially from each other making it difficult for programmers to develop portable threaded applications
In order to take full advantage of the capabilities provided by threads a standardized programming interface was required For UNIX systems this interface has been specified by the IEEE POSIX 10031c standard (1995) Implementations which adhere to this standard are referred to as POSIX threads or Pthreads
Pthreads are defined as a set of C language programming types and procedure calls implemented with a pthreadh headerinclude file and a thread library
Common in Unix
Operating Systems Theory - Threads 19
Windows XP Threads
Implements the one-to-one mapping Each thread contains
1048698A thread id 1048698Register set 1048698Separate user and kernel stacks 1048698Private 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 1048698ETHREAD (executive thread block) 1048698KTHREAD (kernel thread block) 1048698TEB (thread environment block)
Operating Systems Theory - Threads 20
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)
Operating Systems Theory - Threads 21
Linux Threads Thread operations include thread creation termination synchronization
(joinsblocking) scheduling data management and process interaction A thread does not maintain a list of created threads nor does it know the thread
that created it All threads within a process share the same address space Threads in the same process share
Process instructions Most data open files (descriptors) signals and signal handlers current working directory User and group id
Each thread has a unique Thread ID set of registers stack pointer stack for local variables return addresses signal mask priority Return value errno
pthread functions return 0 if OK
Operating Systems Theory - Threads 22
Linux Threadsinclude ltstdiohgt include ltstdlibhgt include ltpthreadhgt
void print_message_function( void ptr ) char message message = (char ) ptr printf(s n message)
main()pthread_t thread1 thread2char message1 = Thread 1char message2 = Thread 2int iret1 iret2
iret1 = pthread_create( ampthread1 NULL print_message_function (void) message1)iret2 = pthread_create( ampthread2 NULL print_message_function (void) message2)
pthread_join( thread1 NULL)pthread_join( thread2 NULL)
printf(Thread 1 returns dniret1)printf(Thread 2 returns dniret2)exit(0)
Operating Systems Theory - Threads 23
Linux Threads
Output Thread 1 Thread 2 Thread 1 returns 0 Thread 2 returns 0
Threads terminate by explicitly calling pthread_exit by letting the function return or by a call to the function exit which will terminate the process including any threads
Operating Systems Theory - Threads 24
Java Threads
Java threads are managed by the JVM Java threads may be created by
1048698Extending Thread class 1048698Implementing the Runnable interface
Operating Systems Theory - Threads 25
Java Threads Every thread has a priority Threads with higher priority are executed in
preference to threads with lower priority Each thread may or may not also be marked as a daemon When code running in some thread creates a new Thread object the new thread has its priority initially set equal to the priority of the creating thread and is a daemon thread if and only if the creating thread is a daemon
When a Java Virtual Machine starts up there is usually a single non-daemon thread (which typically calls the method named main of some designated class) The Java Virtual Machine continues to execute threads until either of the following occurs The exit method of class Runtime has been called and the security
manager has permitted the exit operation to take place All threads that are not daemon threads have died either by returning
from the call to the run method or by throwing an exception that propagates beyond the run method
There are two ways to create a new thread of execution One is to declare a class to be a subclass of Thread This subclass should override the run method of class Thread An instance of the subclass can then be allocated and started
Operating Systems Theory - Threads 26
Questions
Thank you for your attention
Any questions
Operating Systems Theory - Threads 9
MutiThreading Models - Many to one
1 Many user level threads mapped to single kernel thread
Examples
1 Solaris Green Threads
2 GNU Portable Threads
Operating Systems Theory - Threads 10
MutiThreading Models - One to one
1 Each user-level thread maps to kernel thread
Examples
1 Windows NTXP2000
2 Linux
3 Solaris 9 and later
Operating Systems Theory - Threads 11
MutiThreading Models ndash Many to many
1 Allows many user level threads to be mapped to many kernel threads
2 Allows the operating system to create a sufficient number of kernel threads
Examples
1 Solaris prior to version 9
2 Windows NT2000 with the ThreadFiber package
Operating Systems Theory - Threads 12
MultiThreading Models - Two Level Model
Similar to bdquoMany to Manyrdquo except that it allows a user thread to be bound to kernel thread
Examples IRIX HP-UX Tru64 UNIX Solaris 8 and earlier
Operating Systems Theory - Threads 13
Threading Issues ndash Thread Cancellation
Thread cancellation Terminating a thread before it has finished has two approaches Asynchronous cancellation terminates the
target thread immediately Deferred cancellation allows the target thread
to periodically check if it should be cancelled
Operating Systems Theory - Threads 14
Threading Issues ndash 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
Options 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
Operating Systems Theory - Threads 15
Threading Issues - Thread Pool
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
Operating Systems Theory - Threads 16
Threading Issues ndash 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 (ie when using a thread pool)
Operating Systems Theory - Threads 17
Threading Issues ndash Scheduler Activations
Both MM 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
Operating Systems Theory - Threads 18
PThreads Historically hardware vendors have implemented their own
proprietary versions of threads These implementations differed substantially from each other making it difficult for programmers to develop portable threaded applications
In order to take full advantage of the capabilities provided by threads a standardized programming interface was required For UNIX systems this interface has been specified by the IEEE POSIX 10031c standard (1995) Implementations which adhere to this standard are referred to as POSIX threads or Pthreads
Pthreads are defined as a set of C language programming types and procedure calls implemented with a pthreadh headerinclude file and a thread library
Common in Unix
Operating Systems Theory - Threads 19
Windows XP Threads
Implements the one-to-one mapping Each thread contains
1048698A thread id 1048698Register set 1048698Separate user and kernel stacks 1048698Private 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 1048698ETHREAD (executive thread block) 1048698KTHREAD (kernel thread block) 1048698TEB (thread environment block)
Operating Systems Theory - Threads 20
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)
Operating Systems Theory - Threads 21
Linux Threads Thread operations include thread creation termination synchronization
(joinsblocking) scheduling data management and process interaction A thread does not maintain a list of created threads nor does it know the thread
that created it All threads within a process share the same address space Threads in the same process share
Process instructions Most data open files (descriptors) signals and signal handlers current working directory User and group id
Each thread has a unique Thread ID set of registers stack pointer stack for local variables return addresses signal mask priority Return value errno
pthread functions return 0 if OK
Operating Systems Theory - Threads 22
Linux Threadsinclude ltstdiohgt include ltstdlibhgt include ltpthreadhgt
void print_message_function( void ptr ) char message message = (char ) ptr printf(s n message)
main()pthread_t thread1 thread2char message1 = Thread 1char message2 = Thread 2int iret1 iret2
iret1 = pthread_create( ampthread1 NULL print_message_function (void) message1)iret2 = pthread_create( ampthread2 NULL print_message_function (void) message2)
pthread_join( thread1 NULL)pthread_join( thread2 NULL)
printf(Thread 1 returns dniret1)printf(Thread 2 returns dniret2)exit(0)
Operating Systems Theory - Threads 23
Linux Threads
Output Thread 1 Thread 2 Thread 1 returns 0 Thread 2 returns 0
Threads terminate by explicitly calling pthread_exit by letting the function return or by a call to the function exit which will terminate the process including any threads
Operating Systems Theory - Threads 24
Java Threads
Java threads are managed by the JVM Java threads may be created by
1048698Extending Thread class 1048698Implementing the Runnable interface
Operating Systems Theory - Threads 25
Java Threads Every thread has a priority Threads with higher priority are executed in
preference to threads with lower priority Each thread may or may not also be marked as a daemon When code running in some thread creates a new Thread object the new thread has its priority initially set equal to the priority of the creating thread and is a daemon thread if and only if the creating thread is a daemon
When a Java Virtual Machine starts up there is usually a single non-daemon thread (which typically calls the method named main of some designated class) The Java Virtual Machine continues to execute threads until either of the following occurs The exit method of class Runtime has been called and the security
manager has permitted the exit operation to take place All threads that are not daemon threads have died either by returning
from the call to the run method or by throwing an exception that propagates beyond the run method
There are two ways to create a new thread of execution One is to declare a class to be a subclass of Thread This subclass should override the run method of class Thread An instance of the subclass can then be allocated and started
Operating Systems Theory - Threads 26
Questions
Thank you for your attention
Any questions
Operating Systems Theory - Threads 10
MutiThreading Models - One to one
1 Each user-level thread maps to kernel thread
Examples
1 Windows NTXP2000
2 Linux
3 Solaris 9 and later
Operating Systems Theory - Threads 11
MutiThreading Models ndash Many to many
1 Allows many user level threads to be mapped to many kernel threads
2 Allows the operating system to create a sufficient number of kernel threads
Examples
1 Solaris prior to version 9
2 Windows NT2000 with the ThreadFiber package
Operating Systems Theory - Threads 12
MultiThreading Models - Two Level Model
Similar to bdquoMany to Manyrdquo except that it allows a user thread to be bound to kernel thread
Examples IRIX HP-UX Tru64 UNIX Solaris 8 and earlier
Operating Systems Theory - Threads 13
Threading Issues ndash Thread Cancellation
Thread cancellation Terminating a thread before it has finished has two approaches Asynchronous cancellation terminates the
target thread immediately Deferred cancellation allows the target thread
to periodically check if it should be cancelled
Operating Systems Theory - Threads 14
Threading Issues ndash 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
Options 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
Operating Systems Theory - Threads 15
Threading Issues - Thread Pool
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
Operating Systems Theory - Threads 16
Threading Issues ndash 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 (ie when using a thread pool)
Operating Systems Theory - Threads 17
Threading Issues ndash Scheduler Activations
Both MM 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
Operating Systems Theory - Threads 18
PThreads Historically hardware vendors have implemented their own
proprietary versions of threads These implementations differed substantially from each other making it difficult for programmers to develop portable threaded applications
In order to take full advantage of the capabilities provided by threads a standardized programming interface was required For UNIX systems this interface has been specified by the IEEE POSIX 10031c standard (1995) Implementations which adhere to this standard are referred to as POSIX threads or Pthreads
Pthreads are defined as a set of C language programming types and procedure calls implemented with a pthreadh headerinclude file and a thread library
Common in Unix
Operating Systems Theory - Threads 19
Windows XP Threads
Implements the one-to-one mapping Each thread contains
1048698A thread id 1048698Register set 1048698Separate user and kernel stacks 1048698Private 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 1048698ETHREAD (executive thread block) 1048698KTHREAD (kernel thread block) 1048698TEB (thread environment block)
Operating Systems Theory - Threads 20
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)
Operating Systems Theory - Threads 21
Linux Threads Thread operations include thread creation termination synchronization
(joinsblocking) scheduling data management and process interaction A thread does not maintain a list of created threads nor does it know the thread
that created it All threads within a process share the same address space Threads in the same process share
Process instructions Most data open files (descriptors) signals and signal handlers current working directory User and group id
Each thread has a unique Thread ID set of registers stack pointer stack for local variables return addresses signal mask priority Return value errno
pthread functions return 0 if OK
Operating Systems Theory - Threads 22
Linux Threadsinclude ltstdiohgt include ltstdlibhgt include ltpthreadhgt
void print_message_function( void ptr ) char message message = (char ) ptr printf(s n message)
main()pthread_t thread1 thread2char message1 = Thread 1char message2 = Thread 2int iret1 iret2
iret1 = pthread_create( ampthread1 NULL print_message_function (void) message1)iret2 = pthread_create( ampthread2 NULL print_message_function (void) message2)
pthread_join( thread1 NULL)pthread_join( thread2 NULL)
printf(Thread 1 returns dniret1)printf(Thread 2 returns dniret2)exit(0)
Operating Systems Theory - Threads 23
Linux Threads
Output Thread 1 Thread 2 Thread 1 returns 0 Thread 2 returns 0
Threads terminate by explicitly calling pthread_exit by letting the function return or by a call to the function exit which will terminate the process including any threads
Operating Systems Theory - Threads 24
Java Threads
Java threads are managed by the JVM Java threads may be created by
1048698Extending Thread class 1048698Implementing the Runnable interface
Operating Systems Theory - Threads 25
Java Threads Every thread has a priority Threads with higher priority are executed in
preference to threads with lower priority Each thread may or may not also be marked as a daemon When code running in some thread creates a new Thread object the new thread has its priority initially set equal to the priority of the creating thread and is a daemon thread if and only if the creating thread is a daemon
When a Java Virtual Machine starts up there is usually a single non-daemon thread (which typically calls the method named main of some designated class) The Java Virtual Machine continues to execute threads until either of the following occurs The exit method of class Runtime has been called and the security
manager has permitted the exit operation to take place All threads that are not daemon threads have died either by returning
from the call to the run method or by throwing an exception that propagates beyond the run method
There are two ways to create a new thread of execution One is to declare a class to be a subclass of Thread This subclass should override the run method of class Thread An instance of the subclass can then be allocated and started
Operating Systems Theory - Threads 26
Questions
Thank you for your attention
Any questions
Operating Systems Theory - Threads 11
MutiThreading Models ndash Many to many
1 Allows many user level threads to be mapped to many kernel threads
2 Allows the operating system to create a sufficient number of kernel threads
Examples
1 Solaris prior to version 9
2 Windows NT2000 with the ThreadFiber package
Operating Systems Theory - Threads 12
MultiThreading Models - Two Level Model
Similar to bdquoMany to Manyrdquo except that it allows a user thread to be bound to kernel thread
Examples IRIX HP-UX Tru64 UNIX Solaris 8 and earlier
Operating Systems Theory - Threads 13
Threading Issues ndash Thread Cancellation
Thread cancellation Terminating a thread before it has finished has two approaches Asynchronous cancellation terminates the
target thread immediately Deferred cancellation allows the target thread
to periodically check if it should be cancelled
Operating Systems Theory - Threads 14
Threading Issues ndash 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
Options 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
Operating Systems Theory - Threads 15
Threading Issues - Thread Pool
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
Operating Systems Theory - Threads 16
Threading Issues ndash 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 (ie when using a thread pool)
Operating Systems Theory - Threads 17
Threading Issues ndash Scheduler Activations
Both MM 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
Operating Systems Theory - Threads 18
PThreads Historically hardware vendors have implemented their own
proprietary versions of threads These implementations differed substantially from each other making it difficult for programmers to develop portable threaded applications
In order to take full advantage of the capabilities provided by threads a standardized programming interface was required For UNIX systems this interface has been specified by the IEEE POSIX 10031c standard (1995) Implementations which adhere to this standard are referred to as POSIX threads or Pthreads
Pthreads are defined as a set of C language programming types and procedure calls implemented with a pthreadh headerinclude file and a thread library
Common in Unix
Operating Systems Theory - Threads 19
Windows XP Threads
Implements the one-to-one mapping Each thread contains
1048698A thread id 1048698Register set 1048698Separate user and kernel stacks 1048698Private 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 1048698ETHREAD (executive thread block) 1048698KTHREAD (kernel thread block) 1048698TEB (thread environment block)
Operating Systems Theory - Threads 20
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)
Operating Systems Theory - Threads 21
Linux Threads Thread operations include thread creation termination synchronization
(joinsblocking) scheduling data management and process interaction A thread does not maintain a list of created threads nor does it know the thread
that created it All threads within a process share the same address space Threads in the same process share
Process instructions Most data open files (descriptors) signals and signal handlers current working directory User and group id
Each thread has a unique Thread ID set of registers stack pointer stack for local variables return addresses signal mask priority Return value errno
pthread functions return 0 if OK
Operating Systems Theory - Threads 22
Linux Threadsinclude ltstdiohgt include ltstdlibhgt include ltpthreadhgt
void print_message_function( void ptr ) char message message = (char ) ptr printf(s n message)
main()pthread_t thread1 thread2char message1 = Thread 1char message2 = Thread 2int iret1 iret2
iret1 = pthread_create( ampthread1 NULL print_message_function (void) message1)iret2 = pthread_create( ampthread2 NULL print_message_function (void) message2)
pthread_join( thread1 NULL)pthread_join( thread2 NULL)
printf(Thread 1 returns dniret1)printf(Thread 2 returns dniret2)exit(0)
Operating Systems Theory - Threads 23
Linux Threads
Output Thread 1 Thread 2 Thread 1 returns 0 Thread 2 returns 0
Threads terminate by explicitly calling pthread_exit by letting the function return or by a call to the function exit which will terminate the process including any threads
Operating Systems Theory - Threads 24
Java Threads
Java threads are managed by the JVM Java threads may be created by
1048698Extending Thread class 1048698Implementing the Runnable interface
Operating Systems Theory - Threads 25
Java Threads Every thread has a priority Threads with higher priority are executed in
preference to threads with lower priority Each thread may or may not also be marked as a daemon When code running in some thread creates a new Thread object the new thread has its priority initially set equal to the priority of the creating thread and is a daemon thread if and only if the creating thread is a daemon
When a Java Virtual Machine starts up there is usually a single non-daemon thread (which typically calls the method named main of some designated class) The Java Virtual Machine continues to execute threads until either of the following occurs The exit method of class Runtime has been called and the security
manager has permitted the exit operation to take place All threads that are not daemon threads have died either by returning
from the call to the run method or by throwing an exception that propagates beyond the run method
There are two ways to create a new thread of execution One is to declare a class to be a subclass of Thread This subclass should override the run method of class Thread An instance of the subclass can then be allocated and started
Operating Systems Theory - Threads 26
Questions
Thank you for your attention
Any questions
Operating Systems Theory - Threads 12
MultiThreading Models - Two Level Model
Similar to bdquoMany to Manyrdquo except that it allows a user thread to be bound to kernel thread
Examples IRIX HP-UX Tru64 UNIX Solaris 8 and earlier
Operating Systems Theory - Threads 13
Threading Issues ndash Thread Cancellation
Thread cancellation Terminating a thread before it has finished has two approaches Asynchronous cancellation terminates the
target thread immediately Deferred cancellation allows the target thread
to periodically check if it should be cancelled
Operating Systems Theory - Threads 14
Threading Issues ndash 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
Options 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
Operating Systems Theory - Threads 15
Threading Issues - Thread Pool
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
Operating Systems Theory - Threads 16
Threading Issues ndash 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 (ie when using a thread pool)
Operating Systems Theory - Threads 17
Threading Issues ndash Scheduler Activations
Both MM 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
Operating Systems Theory - Threads 18
PThreads Historically hardware vendors have implemented their own
proprietary versions of threads These implementations differed substantially from each other making it difficult for programmers to develop portable threaded applications
In order to take full advantage of the capabilities provided by threads a standardized programming interface was required For UNIX systems this interface has been specified by the IEEE POSIX 10031c standard (1995) Implementations which adhere to this standard are referred to as POSIX threads or Pthreads
Pthreads are defined as a set of C language programming types and procedure calls implemented with a pthreadh headerinclude file and a thread library
Common in Unix
Operating Systems Theory - Threads 19
Windows XP Threads
Implements the one-to-one mapping Each thread contains
1048698A thread id 1048698Register set 1048698Separate user and kernel stacks 1048698Private 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 1048698ETHREAD (executive thread block) 1048698KTHREAD (kernel thread block) 1048698TEB (thread environment block)
Operating Systems Theory - Threads 20
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)
Operating Systems Theory - Threads 21
Linux Threads Thread operations include thread creation termination synchronization
(joinsblocking) scheduling data management and process interaction A thread does not maintain a list of created threads nor does it know the thread
that created it All threads within a process share the same address space Threads in the same process share
Process instructions Most data open files (descriptors) signals and signal handlers current working directory User and group id
Each thread has a unique Thread ID set of registers stack pointer stack for local variables return addresses signal mask priority Return value errno
pthread functions return 0 if OK
Operating Systems Theory - Threads 22
Linux Threadsinclude ltstdiohgt include ltstdlibhgt include ltpthreadhgt
void print_message_function( void ptr ) char message message = (char ) ptr printf(s n message)
main()pthread_t thread1 thread2char message1 = Thread 1char message2 = Thread 2int iret1 iret2
iret1 = pthread_create( ampthread1 NULL print_message_function (void) message1)iret2 = pthread_create( ampthread2 NULL print_message_function (void) message2)
pthread_join( thread1 NULL)pthread_join( thread2 NULL)
printf(Thread 1 returns dniret1)printf(Thread 2 returns dniret2)exit(0)
Operating Systems Theory - Threads 23
Linux Threads
Output Thread 1 Thread 2 Thread 1 returns 0 Thread 2 returns 0
Threads terminate by explicitly calling pthread_exit by letting the function return or by a call to the function exit which will terminate the process including any threads
Operating Systems Theory - Threads 24
Java Threads
Java threads are managed by the JVM Java threads may be created by
1048698Extending Thread class 1048698Implementing the Runnable interface
Operating Systems Theory - Threads 25
Java Threads Every thread has a priority Threads with higher priority are executed in
preference to threads with lower priority Each thread may or may not also be marked as a daemon When code running in some thread creates a new Thread object the new thread has its priority initially set equal to the priority of the creating thread and is a daemon thread if and only if the creating thread is a daemon
When a Java Virtual Machine starts up there is usually a single non-daemon thread (which typically calls the method named main of some designated class) The Java Virtual Machine continues to execute threads until either of the following occurs The exit method of class Runtime has been called and the security
manager has permitted the exit operation to take place All threads that are not daemon threads have died either by returning
from the call to the run method or by throwing an exception that propagates beyond the run method
There are two ways to create a new thread of execution One is to declare a class to be a subclass of Thread This subclass should override the run method of class Thread An instance of the subclass can then be allocated and started
Operating Systems Theory - Threads 26
Questions
Thank you for your attention
Any questions
Operating Systems Theory - Threads 13
Threading Issues ndash Thread Cancellation
Thread cancellation Terminating a thread before it has finished has two approaches Asynchronous cancellation terminates the
target thread immediately Deferred cancellation allows the target thread
to periodically check if it should be cancelled
Operating Systems Theory - Threads 14
Threading Issues ndash 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
Options 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
Operating Systems Theory - Threads 15
Threading Issues - Thread Pool
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
Operating Systems Theory - Threads 16
Threading Issues ndash 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 (ie when using a thread pool)
Operating Systems Theory - Threads 17
Threading Issues ndash Scheduler Activations
Both MM 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
Operating Systems Theory - Threads 18
PThreads Historically hardware vendors have implemented their own
proprietary versions of threads These implementations differed substantially from each other making it difficult for programmers to develop portable threaded applications
In order to take full advantage of the capabilities provided by threads a standardized programming interface was required For UNIX systems this interface has been specified by the IEEE POSIX 10031c standard (1995) Implementations which adhere to this standard are referred to as POSIX threads or Pthreads
Pthreads are defined as a set of C language programming types and procedure calls implemented with a pthreadh headerinclude file and a thread library
Common in Unix
Operating Systems Theory - Threads 19
Windows XP Threads
Implements the one-to-one mapping Each thread contains
1048698A thread id 1048698Register set 1048698Separate user and kernel stacks 1048698Private 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 1048698ETHREAD (executive thread block) 1048698KTHREAD (kernel thread block) 1048698TEB (thread environment block)
Operating Systems Theory - Threads 20
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)
Operating Systems Theory - Threads 21
Linux Threads Thread operations include thread creation termination synchronization
(joinsblocking) scheduling data management and process interaction A thread does not maintain a list of created threads nor does it know the thread
that created it All threads within a process share the same address space Threads in the same process share
Process instructions Most data open files (descriptors) signals and signal handlers current working directory User and group id
Each thread has a unique Thread ID set of registers stack pointer stack for local variables return addresses signal mask priority Return value errno
pthread functions return 0 if OK
Operating Systems Theory - Threads 22
Linux Threadsinclude ltstdiohgt include ltstdlibhgt include ltpthreadhgt
void print_message_function( void ptr ) char message message = (char ) ptr printf(s n message)
main()pthread_t thread1 thread2char message1 = Thread 1char message2 = Thread 2int iret1 iret2
iret1 = pthread_create( ampthread1 NULL print_message_function (void) message1)iret2 = pthread_create( ampthread2 NULL print_message_function (void) message2)
pthread_join( thread1 NULL)pthread_join( thread2 NULL)
printf(Thread 1 returns dniret1)printf(Thread 2 returns dniret2)exit(0)
Operating Systems Theory - Threads 23
Linux Threads
Output Thread 1 Thread 2 Thread 1 returns 0 Thread 2 returns 0
Threads terminate by explicitly calling pthread_exit by letting the function return or by a call to the function exit which will terminate the process including any threads
Operating Systems Theory - Threads 24
Java Threads
Java threads are managed by the JVM Java threads may be created by
1048698Extending Thread class 1048698Implementing the Runnable interface
Operating Systems Theory - Threads 25
Java Threads Every thread has a priority Threads with higher priority are executed in
preference to threads with lower priority Each thread may or may not also be marked as a daemon When code running in some thread creates a new Thread object the new thread has its priority initially set equal to the priority of the creating thread and is a daemon thread if and only if the creating thread is a daemon
When a Java Virtual Machine starts up there is usually a single non-daemon thread (which typically calls the method named main of some designated class) The Java Virtual Machine continues to execute threads until either of the following occurs The exit method of class Runtime has been called and the security
manager has permitted the exit operation to take place All threads that are not daemon threads have died either by returning
from the call to the run method or by throwing an exception that propagates beyond the run method
There are two ways to create a new thread of execution One is to declare a class to be a subclass of Thread This subclass should override the run method of class Thread An instance of the subclass can then be allocated and started
Operating Systems Theory - Threads 26
Questions
Thank you for your attention
Any questions
Operating Systems Theory - Threads 14
Threading Issues ndash 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
Options 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
Operating Systems Theory - Threads 15
Threading Issues - Thread Pool
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
Operating Systems Theory - Threads 16
Threading Issues ndash 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 (ie when using a thread pool)
Operating Systems Theory - Threads 17
Threading Issues ndash Scheduler Activations
Both MM 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
Operating Systems Theory - Threads 18
PThreads Historically hardware vendors have implemented their own
proprietary versions of threads These implementations differed substantially from each other making it difficult for programmers to develop portable threaded applications
In order to take full advantage of the capabilities provided by threads a standardized programming interface was required For UNIX systems this interface has been specified by the IEEE POSIX 10031c standard (1995) Implementations which adhere to this standard are referred to as POSIX threads or Pthreads
Pthreads are defined as a set of C language programming types and procedure calls implemented with a pthreadh headerinclude file and a thread library
Common in Unix
Operating Systems Theory - Threads 19
Windows XP Threads
Implements the one-to-one mapping Each thread contains
1048698A thread id 1048698Register set 1048698Separate user and kernel stacks 1048698Private 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 1048698ETHREAD (executive thread block) 1048698KTHREAD (kernel thread block) 1048698TEB (thread environment block)
Operating Systems Theory - Threads 20
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)
Operating Systems Theory - Threads 21
Linux Threads Thread operations include thread creation termination synchronization
(joinsblocking) scheduling data management and process interaction A thread does not maintain a list of created threads nor does it know the thread
that created it All threads within a process share the same address space Threads in the same process share
Process instructions Most data open files (descriptors) signals and signal handlers current working directory User and group id
Each thread has a unique Thread ID set of registers stack pointer stack for local variables return addresses signal mask priority Return value errno
pthread functions return 0 if OK
Operating Systems Theory - Threads 22
Linux Threadsinclude ltstdiohgt include ltstdlibhgt include ltpthreadhgt
void print_message_function( void ptr ) char message message = (char ) ptr printf(s n message)
main()pthread_t thread1 thread2char message1 = Thread 1char message2 = Thread 2int iret1 iret2
iret1 = pthread_create( ampthread1 NULL print_message_function (void) message1)iret2 = pthread_create( ampthread2 NULL print_message_function (void) message2)
pthread_join( thread1 NULL)pthread_join( thread2 NULL)
printf(Thread 1 returns dniret1)printf(Thread 2 returns dniret2)exit(0)
Operating Systems Theory - Threads 23
Linux Threads
Output Thread 1 Thread 2 Thread 1 returns 0 Thread 2 returns 0
Threads terminate by explicitly calling pthread_exit by letting the function return or by a call to the function exit which will terminate the process including any threads
Operating Systems Theory - Threads 24
Java Threads
Java threads are managed by the JVM Java threads may be created by
1048698Extending Thread class 1048698Implementing the Runnable interface
Operating Systems Theory - Threads 25
Java Threads Every thread has a priority Threads with higher priority are executed in
preference to threads with lower priority Each thread may or may not also be marked as a daemon When code running in some thread creates a new Thread object the new thread has its priority initially set equal to the priority of the creating thread and is a daemon thread if and only if the creating thread is a daemon
When a Java Virtual Machine starts up there is usually a single non-daemon thread (which typically calls the method named main of some designated class) The Java Virtual Machine continues to execute threads until either of the following occurs The exit method of class Runtime has been called and the security
manager has permitted the exit operation to take place All threads that are not daemon threads have died either by returning
from the call to the run method or by throwing an exception that propagates beyond the run method
There are two ways to create a new thread of execution One is to declare a class to be a subclass of Thread This subclass should override the run method of class Thread An instance of the subclass can then be allocated and started
Operating Systems Theory - Threads 26
Questions
Thank you for your attention
Any questions
Operating Systems Theory - Threads 15
Threading Issues - Thread Pool
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
Operating Systems Theory - Threads 16
Threading Issues ndash 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 (ie when using a thread pool)
Operating Systems Theory - Threads 17
Threading Issues ndash Scheduler Activations
Both MM 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
Operating Systems Theory - Threads 18
PThreads Historically hardware vendors have implemented their own
proprietary versions of threads These implementations differed substantially from each other making it difficult for programmers to develop portable threaded applications
In order to take full advantage of the capabilities provided by threads a standardized programming interface was required For UNIX systems this interface has been specified by the IEEE POSIX 10031c standard (1995) Implementations which adhere to this standard are referred to as POSIX threads or Pthreads
Pthreads are defined as a set of C language programming types and procedure calls implemented with a pthreadh headerinclude file and a thread library
Common in Unix
Operating Systems Theory - Threads 19
Windows XP Threads
Implements the one-to-one mapping Each thread contains
1048698A thread id 1048698Register set 1048698Separate user and kernel stacks 1048698Private 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 1048698ETHREAD (executive thread block) 1048698KTHREAD (kernel thread block) 1048698TEB (thread environment block)
Operating Systems Theory - Threads 20
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)
Operating Systems Theory - Threads 21
Linux Threads Thread operations include thread creation termination synchronization
(joinsblocking) scheduling data management and process interaction A thread does not maintain a list of created threads nor does it know the thread
that created it All threads within a process share the same address space Threads in the same process share
Process instructions Most data open files (descriptors) signals and signal handlers current working directory User and group id
Each thread has a unique Thread ID set of registers stack pointer stack for local variables return addresses signal mask priority Return value errno
pthread functions return 0 if OK
Operating Systems Theory - Threads 22
Linux Threadsinclude ltstdiohgt include ltstdlibhgt include ltpthreadhgt
void print_message_function( void ptr ) char message message = (char ) ptr printf(s n message)
main()pthread_t thread1 thread2char message1 = Thread 1char message2 = Thread 2int iret1 iret2
iret1 = pthread_create( ampthread1 NULL print_message_function (void) message1)iret2 = pthread_create( ampthread2 NULL print_message_function (void) message2)
pthread_join( thread1 NULL)pthread_join( thread2 NULL)
printf(Thread 1 returns dniret1)printf(Thread 2 returns dniret2)exit(0)
Operating Systems Theory - Threads 23
Linux Threads
Output Thread 1 Thread 2 Thread 1 returns 0 Thread 2 returns 0
Threads terminate by explicitly calling pthread_exit by letting the function return or by a call to the function exit which will terminate the process including any threads
Operating Systems Theory - Threads 24
Java Threads
Java threads are managed by the JVM Java threads may be created by
1048698Extending Thread class 1048698Implementing the Runnable interface
Operating Systems Theory - Threads 25
Java Threads Every thread has a priority Threads with higher priority are executed in
preference to threads with lower priority Each thread may or may not also be marked as a daemon When code running in some thread creates a new Thread object the new thread has its priority initially set equal to the priority of the creating thread and is a daemon thread if and only if the creating thread is a daemon
When a Java Virtual Machine starts up there is usually a single non-daemon thread (which typically calls the method named main of some designated class) The Java Virtual Machine continues to execute threads until either of the following occurs The exit method of class Runtime has been called and the security
manager has permitted the exit operation to take place All threads that are not daemon threads have died either by returning
from the call to the run method or by throwing an exception that propagates beyond the run method
There are two ways to create a new thread of execution One is to declare a class to be a subclass of Thread This subclass should override the run method of class Thread An instance of the subclass can then be allocated and started
Operating Systems Theory - Threads 26
Questions
Thank you for your attention
Any questions
Operating Systems Theory - Threads 16
Threading Issues ndash 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 (ie when using a thread pool)
Operating Systems Theory - Threads 17
Threading Issues ndash Scheduler Activations
Both MM 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
Operating Systems Theory - Threads 18
PThreads Historically hardware vendors have implemented their own
proprietary versions of threads These implementations differed substantially from each other making it difficult for programmers to develop portable threaded applications
In order to take full advantage of the capabilities provided by threads a standardized programming interface was required For UNIX systems this interface has been specified by the IEEE POSIX 10031c standard (1995) Implementations which adhere to this standard are referred to as POSIX threads or Pthreads
Pthreads are defined as a set of C language programming types and procedure calls implemented with a pthreadh headerinclude file and a thread library
Common in Unix
Operating Systems Theory - Threads 19
Windows XP Threads
Implements the one-to-one mapping Each thread contains
1048698A thread id 1048698Register set 1048698Separate user and kernel stacks 1048698Private 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 1048698ETHREAD (executive thread block) 1048698KTHREAD (kernel thread block) 1048698TEB (thread environment block)
Operating Systems Theory - Threads 20
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)
Operating Systems Theory - Threads 21
Linux Threads Thread operations include thread creation termination synchronization
(joinsblocking) scheduling data management and process interaction A thread does not maintain a list of created threads nor does it know the thread
that created it All threads within a process share the same address space Threads in the same process share
Process instructions Most data open files (descriptors) signals and signal handlers current working directory User and group id
Each thread has a unique Thread ID set of registers stack pointer stack for local variables return addresses signal mask priority Return value errno
pthread functions return 0 if OK
Operating Systems Theory - Threads 22
Linux Threadsinclude ltstdiohgt include ltstdlibhgt include ltpthreadhgt
void print_message_function( void ptr ) char message message = (char ) ptr printf(s n message)
main()pthread_t thread1 thread2char message1 = Thread 1char message2 = Thread 2int iret1 iret2
iret1 = pthread_create( ampthread1 NULL print_message_function (void) message1)iret2 = pthread_create( ampthread2 NULL print_message_function (void) message2)
pthread_join( thread1 NULL)pthread_join( thread2 NULL)
printf(Thread 1 returns dniret1)printf(Thread 2 returns dniret2)exit(0)
Operating Systems Theory - Threads 23
Linux Threads
Output Thread 1 Thread 2 Thread 1 returns 0 Thread 2 returns 0
Threads terminate by explicitly calling pthread_exit by letting the function return or by a call to the function exit which will terminate the process including any threads
Operating Systems Theory - Threads 24
Java Threads
Java threads are managed by the JVM Java threads may be created by
1048698Extending Thread class 1048698Implementing the Runnable interface
Operating Systems Theory - Threads 25
Java Threads Every thread has a priority Threads with higher priority are executed in
preference to threads with lower priority Each thread may or may not also be marked as a daemon When code running in some thread creates a new Thread object the new thread has its priority initially set equal to the priority of the creating thread and is a daemon thread if and only if the creating thread is a daemon
When a Java Virtual Machine starts up there is usually a single non-daemon thread (which typically calls the method named main of some designated class) The Java Virtual Machine continues to execute threads until either of the following occurs The exit method of class Runtime has been called and the security
manager has permitted the exit operation to take place All threads that are not daemon threads have died either by returning
from the call to the run method or by throwing an exception that propagates beyond the run method
There are two ways to create a new thread of execution One is to declare a class to be a subclass of Thread This subclass should override the run method of class Thread An instance of the subclass can then be allocated and started
Operating Systems Theory - Threads 26
Questions
Thank you for your attention
Any questions
Operating Systems Theory - Threads 17
Threading Issues ndash Scheduler Activations
Both MM 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
Operating Systems Theory - Threads 18
PThreads Historically hardware vendors have implemented their own
proprietary versions of threads These implementations differed substantially from each other making it difficult for programmers to develop portable threaded applications
In order to take full advantage of the capabilities provided by threads a standardized programming interface was required For UNIX systems this interface has been specified by the IEEE POSIX 10031c standard (1995) Implementations which adhere to this standard are referred to as POSIX threads or Pthreads
Pthreads are defined as a set of C language programming types and procedure calls implemented with a pthreadh headerinclude file and a thread library
Common in Unix
Operating Systems Theory - Threads 19
Windows XP Threads
Implements the one-to-one mapping Each thread contains
1048698A thread id 1048698Register set 1048698Separate user and kernel stacks 1048698Private 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 1048698ETHREAD (executive thread block) 1048698KTHREAD (kernel thread block) 1048698TEB (thread environment block)
Operating Systems Theory - Threads 20
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)
Operating Systems Theory - Threads 21
Linux Threads Thread operations include thread creation termination synchronization
(joinsblocking) scheduling data management and process interaction A thread does not maintain a list of created threads nor does it know the thread
that created it All threads within a process share the same address space Threads in the same process share
Process instructions Most data open files (descriptors) signals and signal handlers current working directory User and group id
Each thread has a unique Thread ID set of registers stack pointer stack for local variables return addresses signal mask priority Return value errno
pthread functions return 0 if OK
Operating Systems Theory - Threads 22
Linux Threadsinclude ltstdiohgt include ltstdlibhgt include ltpthreadhgt
void print_message_function( void ptr ) char message message = (char ) ptr printf(s n message)
main()pthread_t thread1 thread2char message1 = Thread 1char message2 = Thread 2int iret1 iret2
iret1 = pthread_create( ampthread1 NULL print_message_function (void) message1)iret2 = pthread_create( ampthread2 NULL print_message_function (void) message2)
pthread_join( thread1 NULL)pthread_join( thread2 NULL)
printf(Thread 1 returns dniret1)printf(Thread 2 returns dniret2)exit(0)
Operating Systems Theory - Threads 23
Linux Threads
Output Thread 1 Thread 2 Thread 1 returns 0 Thread 2 returns 0
Threads terminate by explicitly calling pthread_exit by letting the function return or by a call to the function exit which will terminate the process including any threads
Operating Systems Theory - Threads 24
Java Threads
Java threads are managed by the JVM Java threads may be created by
1048698Extending Thread class 1048698Implementing the Runnable interface
Operating Systems Theory - Threads 25
Java Threads Every thread has a priority Threads with higher priority are executed in
preference to threads with lower priority Each thread may or may not also be marked as a daemon When code running in some thread creates a new Thread object the new thread has its priority initially set equal to the priority of the creating thread and is a daemon thread if and only if the creating thread is a daemon
When a Java Virtual Machine starts up there is usually a single non-daemon thread (which typically calls the method named main of some designated class) The Java Virtual Machine continues to execute threads until either of the following occurs The exit method of class Runtime has been called and the security
manager has permitted the exit operation to take place All threads that are not daemon threads have died either by returning
from the call to the run method or by throwing an exception that propagates beyond the run method
There are two ways to create a new thread of execution One is to declare a class to be a subclass of Thread This subclass should override the run method of class Thread An instance of the subclass can then be allocated and started
Operating Systems Theory - Threads 26
Questions
Thank you for your attention
Any questions
Operating Systems Theory - Threads 18
PThreads Historically hardware vendors have implemented their own
proprietary versions of threads These implementations differed substantially from each other making it difficult for programmers to develop portable threaded applications
In order to take full advantage of the capabilities provided by threads a standardized programming interface was required For UNIX systems this interface has been specified by the IEEE POSIX 10031c standard (1995) Implementations which adhere to this standard are referred to as POSIX threads or Pthreads
Pthreads are defined as a set of C language programming types and procedure calls implemented with a pthreadh headerinclude file and a thread library
Common in Unix
Operating Systems Theory - Threads 19
Windows XP Threads
Implements the one-to-one mapping Each thread contains
1048698A thread id 1048698Register set 1048698Separate user and kernel stacks 1048698Private 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 1048698ETHREAD (executive thread block) 1048698KTHREAD (kernel thread block) 1048698TEB (thread environment block)
Operating Systems Theory - Threads 20
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)
Operating Systems Theory - Threads 21
Linux Threads Thread operations include thread creation termination synchronization
(joinsblocking) scheduling data management and process interaction A thread does not maintain a list of created threads nor does it know the thread
that created it All threads within a process share the same address space Threads in the same process share
Process instructions Most data open files (descriptors) signals and signal handlers current working directory User and group id
Each thread has a unique Thread ID set of registers stack pointer stack for local variables return addresses signal mask priority Return value errno
pthread functions return 0 if OK
Operating Systems Theory - Threads 22
Linux Threadsinclude ltstdiohgt include ltstdlibhgt include ltpthreadhgt
void print_message_function( void ptr ) char message message = (char ) ptr printf(s n message)
main()pthread_t thread1 thread2char message1 = Thread 1char message2 = Thread 2int iret1 iret2
iret1 = pthread_create( ampthread1 NULL print_message_function (void) message1)iret2 = pthread_create( ampthread2 NULL print_message_function (void) message2)
pthread_join( thread1 NULL)pthread_join( thread2 NULL)
printf(Thread 1 returns dniret1)printf(Thread 2 returns dniret2)exit(0)
Operating Systems Theory - Threads 23
Linux Threads
Output Thread 1 Thread 2 Thread 1 returns 0 Thread 2 returns 0
Threads terminate by explicitly calling pthread_exit by letting the function return or by a call to the function exit which will terminate the process including any threads
Operating Systems Theory - Threads 24
Java Threads
Java threads are managed by the JVM Java threads may be created by
1048698Extending Thread class 1048698Implementing the Runnable interface
Operating Systems Theory - Threads 25
Java Threads Every thread has a priority Threads with higher priority are executed in
preference to threads with lower priority Each thread may or may not also be marked as a daemon When code running in some thread creates a new Thread object the new thread has its priority initially set equal to the priority of the creating thread and is a daemon thread if and only if the creating thread is a daemon
When a Java Virtual Machine starts up there is usually a single non-daemon thread (which typically calls the method named main of some designated class) The Java Virtual Machine continues to execute threads until either of the following occurs The exit method of class Runtime has been called and the security
manager has permitted the exit operation to take place All threads that are not daemon threads have died either by returning
from the call to the run method or by throwing an exception that propagates beyond the run method
There are two ways to create a new thread of execution One is to declare a class to be a subclass of Thread This subclass should override the run method of class Thread An instance of the subclass can then be allocated and started
Operating Systems Theory - Threads 26
Questions
Thank you for your attention
Any questions
Operating Systems Theory - Threads 19
Windows XP Threads
Implements the one-to-one mapping Each thread contains
1048698A thread id 1048698Register set 1048698Separate user and kernel stacks 1048698Private 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 1048698ETHREAD (executive thread block) 1048698KTHREAD (kernel thread block) 1048698TEB (thread environment block)
Operating Systems Theory - Threads 20
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)
Operating Systems Theory - Threads 21
Linux Threads Thread operations include thread creation termination synchronization
(joinsblocking) scheduling data management and process interaction A thread does not maintain a list of created threads nor does it know the thread
that created it All threads within a process share the same address space Threads in the same process share
Process instructions Most data open files (descriptors) signals and signal handlers current working directory User and group id
Each thread has a unique Thread ID set of registers stack pointer stack for local variables return addresses signal mask priority Return value errno
pthread functions return 0 if OK
Operating Systems Theory - Threads 22
Linux Threadsinclude ltstdiohgt include ltstdlibhgt include ltpthreadhgt
void print_message_function( void ptr ) char message message = (char ) ptr printf(s n message)
main()pthread_t thread1 thread2char message1 = Thread 1char message2 = Thread 2int iret1 iret2
iret1 = pthread_create( ampthread1 NULL print_message_function (void) message1)iret2 = pthread_create( ampthread2 NULL print_message_function (void) message2)
pthread_join( thread1 NULL)pthread_join( thread2 NULL)
printf(Thread 1 returns dniret1)printf(Thread 2 returns dniret2)exit(0)
Operating Systems Theory - Threads 23
Linux Threads
Output Thread 1 Thread 2 Thread 1 returns 0 Thread 2 returns 0
Threads terminate by explicitly calling pthread_exit by letting the function return or by a call to the function exit which will terminate the process including any threads
Operating Systems Theory - Threads 24
Java Threads
Java threads are managed by the JVM Java threads may be created by
1048698Extending Thread class 1048698Implementing the Runnable interface
Operating Systems Theory - Threads 25
Java Threads Every thread has a priority Threads with higher priority are executed in
preference to threads with lower priority Each thread may or may not also be marked as a daemon When code running in some thread creates a new Thread object the new thread has its priority initially set equal to the priority of the creating thread and is a daemon thread if and only if the creating thread is a daemon
When a Java Virtual Machine starts up there is usually a single non-daemon thread (which typically calls the method named main of some designated class) The Java Virtual Machine continues to execute threads until either of the following occurs The exit method of class Runtime has been called and the security
manager has permitted the exit operation to take place All threads that are not daemon threads have died either by returning
from the call to the run method or by throwing an exception that propagates beyond the run method
There are two ways to create a new thread of execution One is to declare a class to be a subclass of Thread This subclass should override the run method of class Thread An instance of the subclass can then be allocated and started
Operating Systems Theory - Threads 26
Questions
Thank you for your attention
Any questions
Operating Systems Theory - Threads 20
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)
Operating Systems Theory - Threads 21
Linux Threads Thread operations include thread creation termination synchronization
(joinsblocking) scheduling data management and process interaction A thread does not maintain a list of created threads nor does it know the thread
that created it All threads within a process share the same address space Threads in the same process share
Process instructions Most data open files (descriptors) signals and signal handlers current working directory User and group id
Each thread has a unique Thread ID set of registers stack pointer stack for local variables return addresses signal mask priority Return value errno
pthread functions return 0 if OK
Operating Systems Theory - Threads 22
Linux Threadsinclude ltstdiohgt include ltstdlibhgt include ltpthreadhgt
void print_message_function( void ptr ) char message message = (char ) ptr printf(s n message)
main()pthread_t thread1 thread2char message1 = Thread 1char message2 = Thread 2int iret1 iret2
iret1 = pthread_create( ampthread1 NULL print_message_function (void) message1)iret2 = pthread_create( ampthread2 NULL print_message_function (void) message2)
pthread_join( thread1 NULL)pthread_join( thread2 NULL)
printf(Thread 1 returns dniret1)printf(Thread 2 returns dniret2)exit(0)
Operating Systems Theory - Threads 23
Linux Threads
Output Thread 1 Thread 2 Thread 1 returns 0 Thread 2 returns 0
Threads terminate by explicitly calling pthread_exit by letting the function return or by a call to the function exit which will terminate the process including any threads
Operating Systems Theory - Threads 24
Java Threads
Java threads are managed by the JVM Java threads may be created by
1048698Extending Thread class 1048698Implementing the Runnable interface
Operating Systems Theory - Threads 25
Java Threads Every thread has a priority Threads with higher priority are executed in
preference to threads with lower priority Each thread may or may not also be marked as a daemon When code running in some thread creates a new Thread object the new thread has its priority initially set equal to the priority of the creating thread and is a daemon thread if and only if the creating thread is a daemon
When a Java Virtual Machine starts up there is usually a single non-daemon thread (which typically calls the method named main of some designated class) The Java Virtual Machine continues to execute threads until either of the following occurs The exit method of class Runtime has been called and the security
manager has permitted the exit operation to take place All threads that are not daemon threads have died either by returning
from the call to the run method or by throwing an exception that propagates beyond the run method
There are two ways to create a new thread of execution One is to declare a class to be a subclass of Thread This subclass should override the run method of class Thread An instance of the subclass can then be allocated and started
Operating Systems Theory - Threads 26
Questions
Thank you for your attention
Any questions
Operating Systems Theory - Threads 21
Linux Threads Thread operations include thread creation termination synchronization
(joinsblocking) scheduling data management and process interaction A thread does not maintain a list of created threads nor does it know the thread
that created it All threads within a process share the same address space Threads in the same process share
Process instructions Most data open files (descriptors) signals and signal handlers current working directory User and group id
Each thread has a unique Thread ID set of registers stack pointer stack for local variables return addresses signal mask priority Return value errno
pthread functions return 0 if OK
Operating Systems Theory - Threads 22
Linux Threadsinclude ltstdiohgt include ltstdlibhgt include ltpthreadhgt
void print_message_function( void ptr ) char message message = (char ) ptr printf(s n message)
main()pthread_t thread1 thread2char message1 = Thread 1char message2 = Thread 2int iret1 iret2
iret1 = pthread_create( ampthread1 NULL print_message_function (void) message1)iret2 = pthread_create( ampthread2 NULL print_message_function (void) message2)
pthread_join( thread1 NULL)pthread_join( thread2 NULL)
printf(Thread 1 returns dniret1)printf(Thread 2 returns dniret2)exit(0)
Operating Systems Theory - Threads 23
Linux Threads
Output Thread 1 Thread 2 Thread 1 returns 0 Thread 2 returns 0
Threads terminate by explicitly calling pthread_exit by letting the function return or by a call to the function exit which will terminate the process including any threads
Operating Systems Theory - Threads 24
Java Threads
Java threads are managed by the JVM Java threads may be created by
1048698Extending Thread class 1048698Implementing the Runnable interface
Operating Systems Theory - Threads 25
Java Threads Every thread has a priority Threads with higher priority are executed in
preference to threads with lower priority Each thread may or may not also be marked as a daemon When code running in some thread creates a new Thread object the new thread has its priority initially set equal to the priority of the creating thread and is a daemon thread if and only if the creating thread is a daemon
When a Java Virtual Machine starts up there is usually a single non-daemon thread (which typically calls the method named main of some designated class) The Java Virtual Machine continues to execute threads until either of the following occurs The exit method of class Runtime has been called and the security
manager has permitted the exit operation to take place All threads that are not daemon threads have died either by returning
from the call to the run method or by throwing an exception that propagates beyond the run method
There are two ways to create a new thread of execution One is to declare a class to be a subclass of Thread This subclass should override the run method of class Thread An instance of the subclass can then be allocated and started
Operating Systems Theory - Threads 26
Questions
Thank you for your attention
Any questions
Operating Systems Theory - Threads 22
Linux Threadsinclude ltstdiohgt include ltstdlibhgt include ltpthreadhgt
void print_message_function( void ptr ) char message message = (char ) ptr printf(s n message)
main()pthread_t thread1 thread2char message1 = Thread 1char message2 = Thread 2int iret1 iret2
iret1 = pthread_create( ampthread1 NULL print_message_function (void) message1)iret2 = pthread_create( ampthread2 NULL print_message_function (void) message2)
pthread_join( thread1 NULL)pthread_join( thread2 NULL)
printf(Thread 1 returns dniret1)printf(Thread 2 returns dniret2)exit(0)
Operating Systems Theory - Threads 23
Linux Threads
Output Thread 1 Thread 2 Thread 1 returns 0 Thread 2 returns 0
Threads terminate by explicitly calling pthread_exit by letting the function return or by a call to the function exit which will terminate the process including any threads
Operating Systems Theory - Threads 24
Java Threads
Java threads are managed by the JVM Java threads may be created by
1048698Extending Thread class 1048698Implementing the Runnable interface
Operating Systems Theory - Threads 25
Java Threads Every thread has a priority Threads with higher priority are executed in
preference to threads with lower priority Each thread may or may not also be marked as a daemon When code running in some thread creates a new Thread object the new thread has its priority initially set equal to the priority of the creating thread and is a daemon thread if and only if the creating thread is a daemon
When a Java Virtual Machine starts up there is usually a single non-daemon thread (which typically calls the method named main of some designated class) The Java Virtual Machine continues to execute threads until either of the following occurs The exit method of class Runtime has been called and the security
manager has permitted the exit operation to take place All threads that are not daemon threads have died either by returning
from the call to the run method or by throwing an exception that propagates beyond the run method
There are two ways to create a new thread of execution One is to declare a class to be a subclass of Thread This subclass should override the run method of class Thread An instance of the subclass can then be allocated and started
Operating Systems Theory - Threads 26
Questions
Thank you for your attention
Any questions
Operating Systems Theory - Threads 23
Linux Threads
Output Thread 1 Thread 2 Thread 1 returns 0 Thread 2 returns 0
Threads terminate by explicitly calling pthread_exit by letting the function return or by a call to the function exit which will terminate the process including any threads
Operating Systems Theory - Threads 24
Java Threads
Java threads are managed by the JVM Java threads may be created by
1048698Extending Thread class 1048698Implementing the Runnable interface
Operating Systems Theory - Threads 25
Java Threads Every thread has a priority Threads with higher priority are executed in
preference to threads with lower priority Each thread may or may not also be marked as a daemon When code running in some thread creates a new Thread object the new thread has its priority initially set equal to the priority of the creating thread and is a daemon thread if and only if the creating thread is a daemon
When a Java Virtual Machine starts up there is usually a single non-daemon thread (which typically calls the method named main of some designated class) The Java Virtual Machine continues to execute threads until either of the following occurs The exit method of class Runtime has been called and the security
manager has permitted the exit operation to take place All threads that are not daemon threads have died either by returning
from the call to the run method or by throwing an exception that propagates beyond the run method
There are two ways to create a new thread of execution One is to declare a class to be a subclass of Thread This subclass should override the run method of class Thread An instance of the subclass can then be allocated and started
Operating Systems Theory - Threads 26
Questions
Thank you for your attention
Any questions
Operating Systems Theory - Threads 24
Java Threads
Java threads are managed by the JVM Java threads may be created by
1048698Extending Thread class 1048698Implementing the Runnable interface
Operating Systems Theory - Threads 25
Java Threads Every thread has a priority Threads with higher priority are executed in
preference to threads with lower priority Each thread may or may not also be marked as a daemon When code running in some thread creates a new Thread object the new thread has its priority initially set equal to the priority of the creating thread and is a daemon thread if and only if the creating thread is a daemon
When a Java Virtual Machine starts up there is usually a single non-daemon thread (which typically calls the method named main of some designated class) The Java Virtual Machine continues to execute threads until either of the following occurs The exit method of class Runtime has been called and the security
manager has permitted the exit operation to take place All threads that are not daemon threads have died either by returning
from the call to the run method or by throwing an exception that propagates beyond the run method
There are two ways to create a new thread of execution One is to declare a class to be a subclass of Thread This subclass should override the run method of class Thread An instance of the subclass can then be allocated and started
Operating Systems Theory - Threads 26
Questions
Thank you for your attention
Any questions
Operating Systems Theory - Threads 25
Java Threads Every thread has a priority Threads with higher priority are executed in
preference to threads with lower priority Each thread may or may not also be marked as a daemon When code running in some thread creates a new Thread object the new thread has its priority initially set equal to the priority of the creating thread and is a daemon thread if and only if the creating thread is a daemon
When a Java Virtual Machine starts up there is usually a single non-daemon thread (which typically calls the method named main of some designated class) The Java Virtual Machine continues to execute threads until either of the following occurs The exit method of class Runtime has been called and the security
manager has permitted the exit operation to take place All threads that are not daemon threads have died either by returning
from the call to the run method or by throwing an exception that propagates beyond the run method
There are two ways to create a new thread of execution One is to declare a class to be a subclass of Thread This subclass should override the run method of class Thread An instance of the subclass can then be allocated and started
Operating Systems Theory - Threads 26
Questions
Thank you for your attention
Any questions
Operating Systems Theory - Threads 26
Questions
Thank you for your attention
Any questions