Presentation is loading. Please wait.

Presentation is loading. Please wait.

Operating Systems Theory Threads

Similar presentations

Presentation on theme: "Operating Systems Theory Threads"— Presentation transcript:

1 Operating Systems Theory Threads
IFE - Computer Science Alexi Akl Operating Systems Theory - Threads

2 Operating Systems Theory - Threads
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 Operating Systems Theory - Threads
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 Operating Systems Theory - Threads
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 NT/XP/2000 2. Linux 3. Solaris 9 and later Operating Systems Theory - Threads

11 MutiThreading Models – 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 NT/2000 with the ThreadFiber package Operating Systems Theory - Threads

12 MultiThreading Models - Two Level Model
Similar to „Many to Many”, except that it allows a user thread to be bound to kernel thread Examples IRIX HP-UX Tru64 UNIX Solaris 8 and earlier Operating Systems Theory - Threads

13 Threading Issues – 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 – 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 – Thread specific data
Allows each thread to have its own copy of data Useful when you do not have control over the thread creation process (i.e., when using a thread pool) Operating Systems Theory - Threads

17 Threading Issues – Scheduler Activations
Both M:M and Two-level models require communication to maintain the appropriate number of kernel threads allocated to the application Scheduler activations provide upcalls-a communication mechanism from the kernel to the thread library This communication allows an application to maintain the correct number kernel threads Operating Systems Theory - Threads

18 Operating Systems Theory - Threads
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 c 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 pthread.h header/include file and a thread library . Common in Unix Operating Systems Theory - Threads

19 Operating Systems Theory - Threads
Windows XP Threads Implements the one-to-one mapping Each thread contains 􀁺A thread id 􀁺Register set 􀁺Separate user and kernel stacks 􀁺Private data storage area The register set, stacks, and private storage area are known as the context of the threads The primary data structures of a thread include: 􀁺ETHREAD (executive thread block) 􀁺KTHREAD (kernel thread block) 􀁺TEB (thread environment block) Operating Systems Theory - Threads

20 Operating Systems Theory - Threads
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 Operating Systems Theory - Threads
Linux Threads Thread operations include thread creation, termination, synchronization (joins,blocking), 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 Operating Systems Theory - Threads
Linux Threads #include <stdio.h> #include <stdlib.h> #include <pthread.h> void *print_message_function( void *ptr ) { char *message; message = (char *) ptr; printf("%s \n", message); } main() { pthread_t thread1, thread2; char *message1 = "Thread 1"; char *message2 = "Thread 2"; int iret1, iret2; iret1 = pthread_create( &thread1, NULL, print_message_function, (void*) message1); iret2 = pthread_create( &thread2, NULL, print_message_function, (void*) message2); pthread_join( thread1, NULL); pthread_join( thread2, NULL); printf("Thread 1 returns: %d\n",iret1); printf("Thread 2 returns: %d\n",iret2); exit(0); } Operating Systems Theory - Threads

23 Operating Systems Theory - Threads
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 Operating Systems Theory - Threads
Java Threads Java threads are managed by the JVM Java threads may be created by: 􀁺Extending Thread class 􀁺Implementing the Runnable interface Operating Systems Theory - Threads

25 Operating Systems Theory - Threads
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

Download ppt "Operating Systems Theory Threads"

Similar presentations

Ads by Google