Chapter 4: Threads

1. Chapter 4: Threads

2. Chapter 4: Threads • Overview • Multithreading Models • Threading Issues • Pthreads • Windows XP Threads • Solaris 2 Threads • Linux Threads • Java Threads

3. Single and Multithreaded Processes

4. Threads • A thread (or lightweight process) is a basic unit of CPU utilization; it consists of: • program counter • register set • stack space • A thread shares with its peer threads its: • code section • data section • operating-system resources collectively known as a task. • A traditional or heavyweight process is equal to a task with one thread

5. Benefits • Responsiveness • Resource Sharing • Economy • Utilization of MP Architectures

6. Threads (Cont.) • In a multiple threaded task, while one server thread is blocked and waiting, a second thread in the same task can run. • Cooperation of multiple threads in same job confers higher throughput and improved performance. • Application that require sharing a common buffer (i.e., producer-consumer) benefit from thread utilization. • Threads provide a mechanism that allows sequential processes to make blocking system calls while also achieving parallelism. • Kernel-supported threads (Mach and OS/2) • User-level threads; supported above the kernel, via a set of library calls at the user level (Project Andrew from CMU). • Hybrid approach implements both user-level and kernel-supported threads (Solaris 2)

7. User Threads • Thread management done by user-level threads library • Examples • POSIX Pthreads • Win32 threads • Java threads • Solaris threads

8. Kernel Threads • Supported by the Kernel • Examples - Windows XP/2000 - Solaris - Linux - Tru64 UNIX - Mac OS X

9. Multithreading Models • Many-to-One • One-to-One • Many-to-Many

10. Many-to-One • Many user-level threads mapped to single kernel thread. • Used on systems that do not support kernel threads.

11. Many-to-One Model

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

13. One-to-one Model

14. Many-to-Many Model • Allows many user level threads to be mapped to many kernel threads. • Allows the operating system to create a sufficient number of kernel threads. • Solaris prior to version 9 • Windows NT/2000 with the ThreadFiber package

15. Many-to-Many Model

16. Two-level Model • Similar to M:M, except that it allows a user thread to be bound to kernel thread • Examples • IRIX • HP-UX • Tru64 UNIX • Solaris 8 and earlier

17. Two-level Model

18. #include <pthread.h> #include <stdio.h> int sum; /* this data is shared by the thread(s) */ void *runner( void * param ); /* the thread */ int main( int argc, char * argv[] ) { pthread_t tid; /* the thread identifier */ pthread_attr_t attr; /* set of thread attributes */ if( argc != 2 ) { fprintf( stderr, "usage: a.out <integer value>\n" ); return -1; } if( atoi(argv[1]) < 0 ) { fprintf( stderr, "%d must be >= 0\n", atoi( argv[1] ) ); return -1; } /* get the default attributes */ pthread_attr_init( &attr, runner, argv[v] ); /* create the thread */ pthread_create( &tid, &attr, runner, argv[1] ); /* wait for the thread to exit */ pthread_join( tid, NULL ); printf( "sum = %d\n", sum ); } Multithreaded C program using the Pthreads API (1)

19. Multithreaded C program using the Pthreads API (2) /* The thread will begin control in this function */ void *runner( void * param ) { int i, upper = atoi( param ); sum = 0; for( i = 1; i <= upper; i++ ) sum += i; pthread_exit( 0 ); }

20. Java program for the summation of a non-negative integer (1) class Sum { private int sum; public int getSum(){ return sum; } public void setSum( int sum ) { this.sum = sum; } } class Summation implements Runnable { private int upper; private Sum sumValue; public Summation( int upper, Sum sumValue ) { this.upper = upper; this.sumValue = sumValue; } public void run() { int sum = 0; for( int i; i <= upper; i++ ) sum += 1; sumValue.setSum( sum ); } }

21. Java program for the summation of a non-negative integer (2) public class Driver { public static void main( String[] args ) { if( args.length > 0 ) { if( Integer.parseInt( args[0] ) < 0 ) System.err.println( args[0] + " must be >= 0." ); else { // create the object to be shared Sum sumObject = new Sum(); int upper = Integer.parseInt( args[0] ); Thread thrd = new Thread( new Summation( upper, sumObject ) ); thrd.start(); try { thrd.join(); System.out.println( "The sum of " + upper + " is " + sumObject.getSum() ); } catch ( InterruptedException ie ){} } } else System.err.println( "Usage: Summation <integer value>" ); } }

22. Threading Issues • Semantics of fork() and exec() system calls • Thread cancellation • Signal handling • Thread pools • Thread specific data • Scheduler activations

23. Semantics of fork() and exec() • Does fork() duplicate only the calling thread or all threads?

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

25. 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 threa to receive all signals for the process

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

27. 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)

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

29. 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)

30. Threads Support in Solaris 2 • Solaris 2 is a version of UNIX with support for threads at the kernel and user levels, symmetric multiprocessing, and real-time scheduling • LWP – intermediate level between user-level threads and kernel-level threads. • Resource needs of thread types: • Kernel thread: small data structure and a stack; thread switching does not require changing memory access information – relatively fast. • LWP: PCB with register data, accounting and memory information; switching between LWPs is relatively slow • User-level thread: only need stack and program counter; no kernel involvement means fast switching. Kernel only sees the LWPs that support user-level threads.

31. Solaris 2 Threads

32. Solaris Process

33. 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)

34. 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)

35. Java Threads • Java threads are managed by the JVM • Java threads may be created by: • Extending Thread class • Implementing the Runnable interface

36. Java Thread States

37. Extentding the Thread Class Class Worker1 extends Thread { public void run() { System.out.println(“I am a Worker Thread”); } }

38. Creating the Thread Public class First { public static void main(String args[]) { Worker runner = new Worker1(); runner.start(); System.out.println(“I am the main thread”); } }

39. The Runnable Interface Public interface Runnable { public abstract void run(); }

40. Implementing the Runnable Interface Class Worker2 implements Runnable { public void run() { System.out.println(“I am a Worker Thread”); } }

41. Creating the 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”); } }

42. Java Thread Management • suspend() – suspends execution of the currently running thread • sleep() – puts the currently running thread to sleep for a specified amount of time • resume() – resumes execution of a suspended thread • stop() – stops execution of a thread

43. /** * ClockApplet.java (그림5.9) * This applet displays the time of day. * Note that this program uses deprecated methods, * an alternative version will be shown in chapter 8. */ import java.applet.*; import java.awt.*; public class ClockApplet extends Applet implements Runnable { public void run() { while (true) { try { Thread.sleep(1000); } catch (InterruptedException e) {}

44. repaint(); } } public void start() { if (clockThread == null) { clockThread = new Thread(this); clockThread.start(); } else clockThread.resume(); }

45. // this method is called when we leave the page the applet is on public void stop() { if (clockThread != null) clockThread.suspend(); } // this method is called when the applet is removed from the cache public void destroy() { if (clockThread != null) { clockThread.stop(); clockThread = null; } }

46. public void paint(Graphics g) { g.drawString(new java.util.Date().toString(), 10, 30); } private Thread clockThread; }

47. /* Server.java (그림 5.11) * This creates the buffer and the producer and consumer threads. */ public class Server { public Server() { // first create the message buffer MessageQueue mailBox = new MessageQueue(); // now create the producer and consumer threads Producer producerThread = new Producer(mailBox); Consumer consumerThread = new Consumer(mailBox);

48. producerThread.start(); consumerThread.start(); } public static void main(String args[]) { Server server = new Server(); } public static final int NAP_TIME = 5; }

49. /* * Producer.java (그림 5.12) * * This is the producer thread for the bounded buffer problem. */ import java.util.*; class Producer extends Thread { public Producer(MessageQueue m) { mbox = m; }

50. public void run() { Date message; while (true) { int sleetime = (int) (Server.NAP_TIME * Math.random()); System.out.println("Producer sleeping for " + sleeptime + " seconds"); try { Thread.sleep(sleeptime * 1000); } catch (InterruptedException e) {}