Operating System Concepts chapter 4 CS 355 Operating Systems Dr. Matthew Wright Threads Relation to processes • Threads exist as subsets of processes • Threads share memory and state information within a process • Switching between threads is faster than switching between processes Threads Benefits • • • • Responsiveness: one thread can respond to the user if another is busy Resource sharing: threads share resources by default Economy: threads are easier to create and maintain than processes Scalability: use multiple processors easily Challenges • • • • • Dividing activities: Which tasks can run concurrently? Balance: How to use each processor effectively? Data splitting: dividing the data between different cores Data dependency: Does one task depend on data from another? Testing and debugging: more difficult when using threads User vs. Kernel Threads User Threads • Managed by the application • The kernel is not aware of user threads • Programmed using a thread library (e.g. Pthreads, Win32, Java) • Many-to-one mapping Kernel Threads • Managed by the kernel • Applications don’t have to manage threads • Programmed using an API • Most modern operating systems support kernel threads • One-to-one mapping user threads threads library user space kernel space process user threads user space kernel space kernel threads process User vs. Kernel Threads Advantages of user threads over kernel threads • Thread switching does not require kernel mode • Thread scheduling can be application-specific • User threads can run on any operating system, iwthout support from the kernel Disadvantages of user threads compared to kernel threads • If one user thread executes a system call that blocks its process, all other threads within that process are blocked • Threads cannot execute concurrently if multiple processors are available Combined Approach Some operating systems combine the previous two approaches. • Thread creation is done in user space. • Thread scheduling and synchronization done in user or kernel space. • User threads from an application are mapped to some (smaller or equal) number of kernel threads. • Many-to-many mapping or a two-level model user threads threads library user space kernel space kernel threads process process Thread Libraries A thread library provides programmer with API for creating and managing threads Two primary ways of implementing: • Library entirely in user space • Kernel-level library supported by the OS (invoke functions by system calls) POSIX Pthreads • A specification, not an implementation, for thread creation and synchronization • May be provided either as user-level or kernel-level • 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) Example: C program using Pthreads /** * Pthread example program * * @author Gagne, Galvin, Silberschatz * Operating System Concepts with Java, 8th ed, fig. 4.9 */ #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 attributes for the thread */ if (argc != 2) { fprintf(stderr,"usage: a.out <integer value>\n"); return -1; } if (atoi(argv[1]) < 0) { fprintf(stderr,"Argument %d must be non-negative\n",atoi(argv[1])); Java Threads Java threads are managed by the JVM Java threads may be created in two ways: • Extend the Thread class and override its run() method • Implement the Runnable interface (preferred) public interface Runnable { public abstract void run() } Creating a Java thread using a Runnable object: 1. Create an instance of the Thread class and pass the constructor a Runnable object 2. Call the start() method of the thread object Java Example /** * Create a separate thread by implementing the Runnable interface. * * @author Gagne, Galvin, Silberschatz * Operating System Concepts with Java, 8th Ed., Fig. 4.11 */ class Sum { private int sum; public int get() { return sum; } public void set(int sum) { this.sum = sum; } } class Summation implements Runnable { private int upper; private Sum sumValue; Java Threads Note: • If two Java threads are to share data, references to the shared objects must be passed to the threads. • The join() method causes the parent thread to wait for its child to finish processing, and this can throw an InterruptedException. • Java doesn’t specify how the JVM maps java threads to the underlying operating system. • Java threads may be in one of six states: new, runnable, blocked, waiting, timed waiting, terminated • Java provides methods to determine the state of a thread: – isAlive() returns true if a thread is started, but not terminated – getState() returns the state as an enumerated data type Java Threads Java Example /** */** Factory class that creates the MessageQueue class and /** * Theproducer message and queue * the /** consumer threads. * The producer class * * * * The consumer class @author Gagne,Galvin, Galvin,Silberschatz Silberschatz * *@author *@author Gagne, * Gagne, Galvin, Silberschatz Operating System Concepts withJava, Java,8th 8thed, ed,Fig. Fig.4.13 3.21 * *Operating * @author System Gagne, Concepts Galvin, with Silberschatz * Operating System Concepts with Java, 8th ed, Fig. 4.14 */*/*/* Operating System Concepts with Java, 8th ed, Fig. 4.15 */ import java.util.Vector; import java.util.Date; import java.util.Date; import java.util.Date; publicclass classFactory MessageQueue<E> implements Channel<E> public class Producer implements Runnable { { { class Consumer implements Runnable private Vector<E> queue; public {private static void main(String[] Channel<Date> queue; args) { //private create the Channel<Date> message queue queue; public MessageQueue() { Channel<Date> queue = new MessageQueue<Date>(); public Producer(Channel<Date> queue) { queue = new Vector<E>(); public Consumer(Channel<Date> queue) { = queue; }// this.queue this.queue the producer = queue;and consumer threads } create Thread } producer = new Thread(new Producer(queue)); public void send(E item) { Thread consumer = new Thread(new Consumer(queue)); public void run() queue.addElement(item); { public void run() { }// start Datemessage; the message; threads Date producer.start(); public E receive() consumer.start(); while (true){ { while (true) == 0) } if {(queue.size() SleepUtilities.nap(); //nap for awhile return null; } SleepUtilities.nap(); = new Date(); elsemessage // consume an item from the buffer Creating and Cancelling Threads Semantics of fork() and exec() system calls • Does fork() duplicate only the calling thread or all threads? It could be implemented either way. • The exec() system call typically replaces the entire process (all threads) with a new program. 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 • If a thread is cancelled, how do we ensure that the system is stable? • Java provides an interrupt status for each thread. Java Example /** * Example program illustrating thread interruption. * * @author Gagne, Galvin, Silberschatz * Operating System Concepts with Java, 8th Ed., Fig. 4.16 */ public class InterruptibleThread implements Runnable { /** * This thread will continue to run as long * as it is not interrupted. */ 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 */ } Signal Handling • Signals are used in UNIX systems to notify a process that a particular event has occurred. • Synchronous signals: delivered to the thread that caused the signal – examples: division by zero, illegal memory access • Asynchronous signals: generated by an external event, delivered to a process or thread – examples: user input, user termination of process • A signal handler is used to process signals. • 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 Thread Pools • Idea: create a number of threads, place them in a “pool” where they await work. • Advantages: – Usually slightly faster to service a request with an existing thread than to create a new thread. – Allows the number of threads in an application to be bound to the size of the pool, avoiding the creation of an extremely large number of threads. • In Java, the java.util.concurrent package facilitates thread pools via the Executor interface. 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) • Java provides the ThreadLocal class for thread-specific data. • Example… Java Example /** */** Example program illustrating thread-specific data. /** * thread performs a transaction and every transaction is * *Each This service fulfills transactions are purposes, performed by identified by Galvin, aclass separate serial number. Forwhich logging * *@author Gagne, Silberschatz *weseparate threads. Because a transaction may resultbyineach an error, may wish to log the transaction being performed thread.we * *Operating System Concepts with Java, 8th Ed., Fig. 4.18 and 4.19 * need to record the error. However, since there is only a static */ */* instance of this class, there is only one copy of errorCode. If an * error occurs in one Runnable thread, it will set the value of errorCode, class Worker implements public class TSD * however another thread may set it to a different value. The solution { { * to this is to use ThreadLocal copies of errorCode. Every thread that private static Service provider; * causes an error will set its own copy of errorCode. public static void main(String[] args) { */ public void run() { java.util.concurrent.ExecutorService pool = provider.transaction(); class Service java.util.concurrent.Executors.newCachedThreadPool(); System.out.println(Thread.currentThread().getName() + " > " + { + " < "); for (intstatic i = 0;void i < transaction() 5;provider.getErrorCode() i++) { public { } // just for kicks, use a thread pool // fulfill some kind of transaction service } pool.execute(new Worker()); try { Thread.sleep( (int) (Math.random() * 1000) ); } } catch (InterruptedException ie) { } pool.shutdown(); // some operation where an error may occur } try { } int num = (int) (Math.random() * 2); double recip = 1 / num; } catch (Exception e) { Scheduler Activations • Both many-to-many and two-level models require communication between the kernel and the thread library to maintain the appropriate number of kernel threads allocated to the application. • Many systems use an intermediate data structure known as a lightweight process (LWP) between user threads and kernel threads. • The LWP appears as a virtual processor to user threads. • Scheduler activations provide upcalls: a communication mechanism from the kernel to the thread library • Example: If a thread blocks to wait for I/O, the kernel makes an upcall to the thread library. • This communication allows an application to maintain the correct number kernel threads. user thread LWP kernel threads Windows • Windows uses the Win32 and Win64 APIs • Implements a one-to-one mapping of user threads to kernel threads • Offers a fiber library to provide support for the many-to-many model • Each thread contains – A thread id – Register set representing the status of the processor – Separate user and kernel stacks, for when the thread is running in user mode and kernel mode – Private data storage area • The register set, stacks, and private storage area are known as the context of the threads Windows The primary data structures of a thread include: • ETHREAD (executive thread block): includes pointers to the process that owns the thread and to the KTHREAD • KTHREAD (kernel thread block): scheduling and synchronization information • TEB (thread environment block): user-mode data Linux Threads • Linux refers to them as tasks rather than threads • Thread creation is done through clone() system call – clone() requires a set of parameters that determine how much sharing takes place between parent and child tasks • The Linux kernel includes a data structure for each task that contains pointers to structures where data is stored (e.g. list of open files, signal-handling information, virtual memory) – fork() creates a new task and copies the data structure of parent process – clone() creates a new task and allows the new data structure to point to that of the parent