1. H.-H. S. Lee 1 ECE3055 Computer Architecture and Operating Systems Lecture 12 Threads Prof. Hsien-Hsin Sean Lee School of Electrical and Computer Engineering Georgia Institute of Technology

2. H.-H. S. Lee 2 Single and Multithreaded Processes

3. H.-H. S. Lee 3 Examples of Threads  A web browser One thread displays images One thread retrieves data from network  A word processor One thread displays graphics One thread reads keystrokes One thread performs spell checking in the background  A web server One thread accepts requests When a request comes in, separate thread is created to service Many threads to support thousands of client requests  RPC or RMI (Java) One thread receives message Message service uses another thread

4. H.-H. S. Lee 4 Threads vs. Processes Thread  A thread has no data segment or heap  A thread cannot live on its own, it must live within a process  There can be more than one thread in a process, the first thread calls main and has the process’s stack  Inexpensive creation  Inexpensive context switching  If a thread dies, its stack is reclaimed by the process Processes  A process has code/data/heap and other segments  There must be at least one thread in a process  Threads within a process share code/data/heap, share I/O, but each has its own stack and registers  Expense creation  Expensive context switching  It a process dies, its resources are reclaimed and all threads die

5. H.-H. S. Lee 5 Thread Implementation  Process defines address space  Threads share address space  Process Control Block (PCB) contains process-specific info PID, owner, heap pointer, active threads and pointers to thread info  Thread Control Block (TCB) contains thread-specific info Stack pointer, PC, thread state, register … CODE Initialized data Heap Stack – thread 2 Stack – thread 1 DLL’s Reserved Process’s address space $pc $sp State Registers … $pc $sp State Registers … TCB for thread2 TCB for thread1

6. H.-H. S. Lee 6 Benefits  Responsiveness When one thread is blocked, your browser still responds E.g. download images while allowing your interaction  Resource Sharing Share the same address space Reduce overhead (e.g. memory)  Economy Creating a new process costs memory and resources E.g. in Solaris, 30 times slower in creating process than thread  Utilization of MP Architectures Threads can be executed in parallel on multiple processors Increase concurrency and throughput

7. H.-H. S. Lee 7 User-level Threads  Thread management done by user-level threads library  Similar to calling a procedure  Thread management is done by the thread library in user space  User can control the thread scheduling (No disturbing the underlying OS scheduler)  No OS kernel support more portable Low overhead when thread switching  Three primary thread libraries: POSIX Pthreads Java threads Win32 threads

8. H.-H. S. Lee 8 Kernel Threads  A.k.a. lightweight process in the literature  Supported by the Kernel  Thread scheduling is fairer  Examples Windows XP/2000 Solaris Linux Tru64 UNIX Mac OS X

9. H.-H. S. Lee 9 Multithreading Models  Many-to-One  One-to-One  Many-to-Many

10. H.-H. S. Lee 10 Many-to-One  Many user-level threads mapped to one single kernel thread  The entire process will block if a thread makes a blocking system call  Cannot run threads in parallel on multiprocessors  Examples Solaris Green Threads GNU Portable Threads

11. H.-H. S. Lee 11 Many-to-One Model

12. H.-H. S. Lee 12 One-to-One  Each user-level thread maps to kernel thread  Do not block other threads when one is making a blocking system call  Enable parallel execution in an MP system  Downside: performance/memory overheads of creating kernel threads Restriction of the number of threads that can be supported  Examples Windows NT/XP/2000 Linux Solaris 9 and later

13. H.-H. S. Lee 13 One-to-one Model

14. H.-H. S. Lee 14 Many-to-Many Model  Allows many user level threads to be mapped to many kernel threads  Allows the operating system to create a sufficient number of kernel threads  Threads are multiplexed to a smaller (or equal) number of kernel threads which is specific to a particular application or a particular machine  Solaris prior to version 9  Windows NT/2000 with the ThreadFiber package

15. H.-H. S. Lee 15 Many-to-Many Model

16. H.-H. S. Lee 16 Two-level (or Combined) Model  Similar to Many-to-Many, except that it also allows a user thread to be bound to kernel thread  Examples IRIX HP-UX Tru64 UNIX Solaris 8 and earlier (9 uses one-to-one model)

17. H.-H. S. Lee 17 Two-level (or Combined) Model

18. H.-H. S. Lee 18 Threading Issues  Semantics of fork() and exec() system calls  Thread cancellation  Signal handling  Thread pools  Thread specific data  Scheduler activations

19. H.-H. S. Lee 19 Semantics of fork() and exec()  Does fork() duplicate only the calling thread or all threads?  Some UNIX systems have chosen to have 2 versions of fork()  Exec() : The program specified in the parameter to exec() will replace the entire process including all threads if a thread invokes it

20. H.-H. S. Lee 20 Thread Cancellation  Terminating a thread before it has finished  Two general approaches: Asynchronous cancellation terminates the target thread immediately Deferred cancellation allows the target thread to periodically check if it should be cancelled

21. H.-H. S. Lee 21 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 1.Signal is generated by particular event 2.Signal is delivered to a process 3.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 threa to receive all signals for the process

22. H.-H. S. Lee 22 Thread Pools  Create a number of threads in a pool where they await work  Advantages: Usually slightly faster to service a request with an existing thread than create a new thread Allows the number of threads in the application(s) to be bound to the size of the pool

23. H.-H. S. Lee 23 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)

24. H.-H. S. Lee 24 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

25. H.-H. S. Lee 25 Pthreads  A POSIX standard (IEEE 1003.1c) API for thread creation and synchronization  API specifies behavior of the thread library, implementation is up to development of the library  Common in UNIX operating systems (Solaris, Linux, Mac OS X)

26. H.-H. S. Lee 26 Pthreads int sum; /* this data is shared by the thread(s) */ void *runner(void *param); /* the thread */ main(int argc, char *argv[]) { pthread_t tid; /* the thread identifier */ pthread_attr_t attr; /* set of attributes for the thread */ /* get the default attributes */ pthread_attr_init(&attr); /* create the thread */ pthread_create(&tid,&attr,runner,argv[1]); /* now wait for the thread to exit */ pthread_join(tid,NULL); printf("sum = %d\n",sum); } void *runner(void *param) { int upper = atoi(param); int i; sum = 0; if (upper > 0) { for (i = 1; i <= upper; i++) sum += i; } pthread_exit(0); }

27. H.-H. S. Lee 27 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)

28. H.-H. S. Lee 28 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)

29. H.-H. S. Lee 29 Java Threads  Java threads are managed by the JVM  Java threads may be created by: Extending Thread class Implementing the Runnable interface

30. H.-H. S. Lee 30 Extending the Thread Class class Worker1 extends Thread { public void run() { System.out.println("I Am a Worker Thread"); } public class First { public static void main(String args[]) { Worker1 runner = new Worker1(); runner.start(); System.out.println("I Am The Main Thread"); }

31. H.-H. S. Lee 31 The Runnable Interface public interface Runnable { public abstract void run(); }

32. H.-H. S. Lee 32 Implementing the Runnable Interface class Worker2 implements Runnable { public void run() { System.out.println("I Am a Worker Thread "); } public class Second { public static void main(String args[]) { Runnable runner = new Worker2(); Thread thrd = new Thread(runner); thrd.start(); System.out.println("I Am The Main Thread"); }

33. H.-H. S. Lee 33 Java Thread States

34. H.-H. S. Lee 34 Joining Threads class JoinableWorker implements Runnable { public void run() { System.out.println("Worker working"); } public class JoinExample { public static void main(String[] args) { Thread task = new Thread(new JoinableWorker()); task.start(); try { task.join(); } catch (InterruptedException ie) { } System.out.println("Worker done"); }

35. H.-H. S. Lee 35 Thread Cancellation Thread thrd = new Thread (new InterruptibleThread()); Thrd.start();... // now interrupt it Thrd.interrupt();

36. H.-H. S. Lee 36 Thread Cancellation public class InterruptibleThread implements Runnable { public void run() { while (true) { /** * do some work for awhile */ if (Thread.currentThread().isInterrupted()) { System.out.println("I'm interrupted!"); break; } // clean up and terminate }

37. H.-H. S. Lee 37 Thread Specific Data class Service { private static ThreadLocal errorCode = new ThreadLocal(); public static void transaction() { try { /** * some operation where an error may occur */ catch (Exception e) { errorCode.set(e); } /** * get the error code for this transaction */ public static Object getErrorCode() { return errorCode.get(); }

38. H.-H. S. Lee 38 Thread Specific Data class Worker implements Runnable { private static Service provider; public void run() { provider.transaction(); System.out.println(provider.getErrorCode()); }

39. H.-H. S. Lee 39 Producer-Consumer Problem public class Factory { public Factory() { // first create the message buffer Channel mailBox = new MessageQueue(); // now create the producer and consumer threads Thread producerThread = new Thread(new Producer(mailBox)); Thread consumerThread = new Thread(new Consumer(mailBox)); producerThread.start(); consumerThread.start(); } public static void main(String args[]) { Factory server = new Factory(); }

40. H.-H. S. Lee 40 Producer Thread class Producer implements Runnable { private Channel mbox; public Producer(Channel mbox) { this.mbox = mbox; } public void run() { Date message; while (true) { SleepUtilities.nap(); message = new Date(); System.out.println("Producer produced " + message); // produce an item & enter it into the buffer mbox.send(message); }

41. H.-H. S. Lee 41 Consumer Thread class Consumer implements Runnable { private Channel mbox; public Consumer(Channel mbox) { this.mbox = mbox; } public void run() { Date message; while (true) { SleepUtilities.nap(); // consume an item from the buffer System.out.println("Consumer wants to consume."); message = (Date)mbox.receive(); if (message != null) System.out.println("Consumer consumed " + message); }