Lecture Contents. 1. Overview. 2. Multithreading Models 3. Examples of Thread Libraries 4. Summary

Transcription

1 Lecture 4 Threads 1

2 Lecture Contents 1. Overview 2. Multithreading Models 3. Examples of Thread Libraries 4. Summary 2

3 1. Overview Process is the unit of resource allocation and unit of protection. Thread is the basic unit of CPU utilization. In other words, thread is the unit of dispatching. 3

4 1. Overview Single-threaded process (also called heavyweight, task or job) contains one thread (also called lightweight process or miniprocess). It performs only one task at a time. Multithreaded process contains n threads (n = 2, 3, ). It performs more than one task at a time. Unix, Windows, and Java support thread libraries (via APIs). 4

5 Benefits of Threads It takes less time to create a new thread than a process It takes less time to terminate a thread than a process Switching between two threads takes less time than switching between processes Threads enhance efficiency in communication between programs 5

6 1. Overview Thread comprises thread ID, a program counter, a register set, priority, stack, and other threadrelated state information. Each thread of a multithreaded process has its own thread control block. 6

7 1. Overview Thread shares with other threads belonging to same process its code section, data section, open files, and so on. By default, threads share memory (i.e., the process s address space) and resources of the process to which they belong. 7

8 1. Overview Multithreading refers to the ability of an OS to support multiple, concurrent paths of execution within a single process. The difference between single-threaded process and multithreaded process is shown on next slide. 8

9 1. Overview Single-threaded and multithreaded processes. 9

10 Examples of Applications with Multithreaded Process - Web browser might have one thread display images or text while another thread retrieves data from the network. - Word processor may have a thread for displaying graphics, another thread for responding to keystrokes from the user, and a third thread for performing spelling and grammar checking in the background. - Web server has multithreaded process to service many clients as illustrated on next slide. 10

11 Examples of Applications with Multithreaded Process Multithreaded server architecture. Most OS kernels are now multithreaded such as Windows, Linux, Mac OS X, and Solaris. 11

12 Four Benefits of Multithreaded Programming 1. Responsiveness. Multithreading may allow program to continue running even if part of it is blocked or is performing lengthy operation, therefore responsiveness is increased. 2. Resource sharing. Threads share memory and resources of the process to which they belong by default. 12

13 Four Benefits of Multithreaded Programming 3. Economy - As a result of resource sharing, it is more economical to create new threads than new processes. - It is much more time consuming to create and manage processes than threads (e.g., context switching). 13

14 Four Benefits of Multithreaded Programming 4. Scalability (i.e., utilization of multiprocessor architectures ) - Single-threaded process can only execute on one processor regardless of the number of processors actually exists in the computer. - Multithreading can be greatly increased in multiprocessor architecture, where multiple threads can run in parallel on different processors. 14

15 Multicore Programming Multithreaded programming provides mechanism for more efficient use of multiple cores and improved concurrency. Consider application with four threads. - On system with single computing core, concurrency merely means that execution of threads will be interleaved over time (see figure on next slide), as processing core is capable of executing only one thread at a time. 15

16 Multicore Programming Concurrent execution on a single-core system. 16

17 Multicore Programming - On system with multiple cores, concurrency means that threads can run in parallel, as system can assign separate thread to each core. Parallel execution on a multicore system. 17

18 Thread Execution States States associated with a change in thread state - Spawn: when a new process is spawned, a thread for that process is also spawned. - Block: when a thread needs to wait for an event (e.g., I/O), it will block. Processor may execute another ready thread in the same or different process. 18

19 Thread Execution States States associated with a change in thread state - Unblock: the state changes from blocked to ready. - Finish: when a thread completes, its allocated resources (i.e., register context and stacks) are deallocated 19

20 Linux Tasks Linux does not distinguish between process and thread. Linux uses the term task rather than process or thread. A task in Linux is represented by a task_struct data structure This data structure contains the following. - State: ready, executing, blocked, stopped - Scheduling information: priority, allotted time 20

21 Linux Tasks - Identifiers: pid, user and group identifiers - Interprocess communication: - Links: link to its parent process and siblings - Times and timers: include process creation time, processor time used by process, interval timer 21

22 Linux Tasks - File system: includes pointers to files opened by process, pointers to current and root directories for this process - Address space: assigned to this process - Process context: includes registers and stack information of this process 22

23 Solaris Thread States RUN: thread is runnable, i.e., ready to execute ONPROC: thread is executing on processor SLEEP: thread is blocked ZOMBIE: thread has terminated. FREE: Thread resources have been released and thread is awaiting removal from OS thread data structure. 23

24 Solaris Process and Thread Solaris makes use of four separate thread-related concepts. - Process: includes the user s address space, stack, and process control block (PCB). - User-level threads (ULT): is a user-created unit of execution within a process. 24

25 Solaris Process and Thread - Lightweight processes (LWP): can be viewed as a mapping between ULTs and kernel threads. - Kernel threads: can be scheduled and dispatched to run on one of the system processors. 25

26 Windows Thread States Ready: thread may be scheduled for execution. The kernel dispatcher keeps track of all ready threads and schedules them in priority order. Standby: thread has been selected to run next on a particular processor. The thread waits in this state until that processor is made available. 26

27 Windows Thread States Running: Once kernel dispatcher performs a thread switch, standby thread enters Running state and begins execution and continues execution until it is preempted by a higher priority thread, exhausts its time slice, blocks, or terminates. In the first two cases, it goes back to the ready state. 27

28 Windows Thread States Waiting: A thread enters the Waiting state when (1) it is blocked on an event (e.g., I/O), (2) it voluntarily waits for synchronization purposes, or (3) an environment subsystem directs the thread to suspend itself. When the waiting condition is satisfied, the thread moves to the Ready state if all of its resources are available. 28

29 Windows Thread States Transition: A thread enters this state after waiting if it is ready to run but the resources are not available. Terminated: A thread can be terminated by itself, by another thread, or when its parent process terminates. 29

30 Lecture Contents 1. Overview 2. Multithreading Models 3. Examples of Thread Libraries 4. Summary 30

31 2. Multithreading Models Two types of threads are user threads and kernel threads. Contemporary OSs supporting kernel threads include Windows, Linux, Mac OS X, Solaris. Three common relationships between user thread and kernel thread are m:1, 1:1, and m:n (m n). 31

32 Many-to-One Model Many-to-one model maps many user-level threads to one kernel thread. Thread management is done by thread library in user space, so it is efficient (i.e., creating one user thread may not require creating corresponding kernel thread). Solaris uses this model via the green threads (it is a thread library). 32

33 Many-to-One Model Many-to-one model. 33

34 Weaknesses of Many-to-One Model The entire process will block if a thread makes a blocking system call. Only one thread can access the kernel at a time, multiple threads are unable to run in parallel on multicore systems. 34

35 One-to-One Model One-to-one model maps each user thread to a kernel thread. Linux and Windows OSs use one-to-one model. 35

36 One-to-One Model One-to-one model. 36

37 One-to-One Model Strengths: - provides more concurrency than many-to-one model by allowing another thread to run when a thread makes blocking system call. - allows multiple threads to run in parallel on multiprocessors. Weakness - Creating user thread requires creating corresponding kernel thread. 37

38 Many-to-Many Model Many-to-many model multiplexes many userlevel threads to a smaller or equal number of kernel threads (m n). Strengths: - Many-to-many model suffers from neither of shortcomings of m:1 and 1:1 models. 38

39 Many-to-Many Model Many-to-many model. 39

40 Lecture Contents 1. Overview 2. Multithreading Models 3. Examples of Thread Libraries 4. Summary 40

41 3. Examples of Thread Libraries Thread library provides programmer with API for creating and managing threads. Two primary ways of implementing thread library are 1. User-level thread (ULT) library/facility - all code and data structures for thread library reside in user space with no OS support - invoking API function results in local function call in user space, not system call. 41

42 Disadvantages of ULT If one thread is blocked, then the entire process (i.e., all threads within the process) is blocked. Only a single ULT within a process can execute at a time. 42

43 3. Examples of Thread Libraries 2. Kernel-level thread (KLT) library/facility - all code and data structures exist in kernel space so it is supported by OS call. - invoking API function results in system 43

44 Advantages of KLT The kernel can simultaneously schedule multiple threads from the same process on multiple processors. If one thread in a process is blocked, the kernel can schedule another thread of the same process. 44

45 3. Examples of Thread Libraries Windows uses a KLT approach. Solaris uses a combined ULT and KLT approach. 45

46 3. Examples of Thread Libraries Three main thread APIs are: - POSIX Pthreads on UNIX-based OS - Win32 on Windows OS - Java thread API uses thread library of host OS. Example: write multithreaded program that computes sum = n, where value of n is entered on command line. 46

47 Pthread API - Ubuntu Linux Pthreads (refers to specification for thread behavior, not implementation) Pthreads share global data (i.e., global variable sum). 47

48 Pthread API - Linux - pthread_create(&tid, &attr, runner, argv[1]): parent thread creates child thread - pthread_join(tid, NULL): parent thread waits for child thread to terminate - pthread_exit(0): child thread signals its completion. 48

49 Pthread API - Linux - C Program #include <pthread.h> #include <stdio.h> #include <stdlib.h> int sum = 0; // shared by thread(s) void *runner(void *param); /* the thread */ int main(int argc, char *argv[]) { 49

50 Pthread API - Linux - C Program pthread_t tid; // thread identifier pthread_attr_t attr; // attributes int n = 0; if (argc!= 2) { printf("usage: Pthread n\n"); return -1; } n = atoi(argv[1]) 50

51 Pthread API - Linux - C Program if (n < 0) { printf("usage:pthread n >= 0); return -1; } /* get the default attributes */ pthread_attr_init(&attr); 51

52 Pthread API - Linux - C Program /* create the thread */ pthread_create(&tid, &attr, runner, &n); //pthread_create(&tid, NULL, // runner, &n); /*wait for child thread to exit*/ pthread_join(tid, NULL); printf("sum = %d\n", sum); } // main 52

53 Pthread API - Linux - C Program /* The thread will begin control in this function */ void *runner(void *param) { int i, n = *(int*)param; } for (i = 1; i <= n; i++) sum += i; pthread_exit(0); 53

54 Win32 Thread API - Windows Win32 threads share global data (i.e., global variable Sum). 54

55 Win32 Thread API - Windows - CreateThread(NULL, 0, Summation, &n, 0, &ThreadId): parent thread creates child thread - WaitForSingleObject(ThreadHandle, INFINITE): parent thread waits for child thread to terminate - return 0: child thread completes its execution. 55

56 Win32 Thread API - Windows - C/C++ Program #include <windows.h> #include <stdio.h> #include <stdlib.h> /*data is shared by the thread(s)*/ DWORD Sum; 56

57 Win32 Thread API - Windows - C/C++ Program /* the thread runs in this separate function */ DWORD WINAPI Summation(LPVOID Param) { DWORD n = *(DWORD*)Param; } for (DWORD i = 0; i <= n; i++) Sum += i; return 0; 57

58 Win32 Thread API - Windows - C/C++ Program int main(int argc, char *argv[]) { DWORD ThreadId; HANDLE ThreadHandle; int n; 58

59 Win32 Thread API - Windows - C/C++ Program /*perform basic error checking*/ if (argc!= 2) { printf("an integer >= 0 is required\n"); return -1; } 59

60 Win32 Thread API - Windows - C/C++ Program n = atoi(argv[1]); if (n < 0) { printf("an integer >= 0 is required\n"); return -1; } 60

61 Win32 Thread API - Windows - C/C++ Program // create the child thread ThreadHandle = CreateThread( NULL, // default security attributes 0, // default stack size Summation, // thread function &n, // parameter to thread function 0, // default creation flags &ThreadId); // returns the thread identifier 61

62 Win32 Thread API - Windows - C/C++ Program if (ThreadHandle!= NULL) { // now wait for the thread to finish WaitForSingleObject( ThreadHandle, INFINITE); // close the thread handle CloseHandle(ThreadHandle); printf("sum = %d\n", Sum); } } // main 62

63 Java Thread API Two techniques for writing multithreaded Java program are - First approach: extend Thread class and override run() method. That is, create new class that is derived from Thread class and override its run() method. - Second approach (more commonly used): define a class that implements the Runnable interface as follows. 63

64 Java Thread API class Summation implements Runnable { // Data members // Constructors public void run() { // perform required task } } 64

65 Java Thread API - When a class implements Runnable, it must define its run() method. - The code implementing the run() method is what runs as a separate thread. 65

66 Java Thread API - Thread creation is performed by creating object instance of Thread class and passing the constructor of Runnable object. - Creating Thread object does not specifically create new thread. The start() method creates new thread. Calling thrd.start() method for the new object does two things: 66

67 Java Thread API 1. It allocates memory and initializes new thread in the JVM. 2. It calls run() method. Child thread begins execution in run() method of Summation class. 67

68 Java Thread API - Java Program class Sum // object shared by parent/main() // and child/summation threads { private int sum; public int getsum() { return sum; } 68

69 Java Thread API - Java Program public void setsum(int tsum) { sum = tsum; } } // Sum 69

70 Java Thread API - Java Program class Summation implements Runnable // object used to create child thread { private int upper; // n private Sum sumobt; // sumobject 70

71 Java Thread API - Java Program public Summation(int upr, Sum so) { upper = upr; sumobt = so; } 71

72 Java Thread API - Java Program public void run() { // child thread begins its // execution here int sum = 0; for (int i = 0; i <= upper; i++) sum += i; sumobt.setsum(sum); } } // Summation 72

73 Java Thread API - Java Program public class SumApp { public static void main( String[] args) { // main/parent thread if (args.length!= 1) { System.err.println("Usage: SumApp integer >= 0"); System.exit(0); } 73

74 Java Thread API - Java Program int upper = Integer.parseInt(args[0]); if (upper < 0) { System.out.println( "Usage: SumApp integer >= 0"); System.exit(0); } 74

75 Java Thread API - Java Program // create object shared by parent and child threads Sum sumobject = new Sum(); // create Thread object, // it does not create a new/child thread Thread thrd = new Thread( new Summation(upper, sumobject)); 75

76 Java Thread API - Java Program thrd.start(); // creates child thread and calls the run() method try { // parent thread waits for // summation/child thread to finish thrd.join(); } 76

77 Java Thread API - Java Program catch ( InterruptedException ie) { } System.out.println("Sum = " + sumobject.getsum()); } // main() } // public class SumApp 77

78 Lecture Contents 1. Overview 2. Multithreading Models 3. Examples of Thread Libraries 4. Summary 78

79 4. Summary Thread is flow of control within process. A multithreaded process contains several different flows of control within the same address space. Benefits of multithreading include increased responsiveness to user, resource sharing within process, economy, and scalability issues such as more efficient use of multiple cores. 79

80 4. Summary User-level threads are threads that are visible to programmer and are unknown to kernel. OS kernel supports and manages kernel-level threads. Three different types of models relate user and kernel threads: m:1, 1:1, and m:n models. - The m:n model multiplexes many user threads to a smaller or equal number of kernel threads. 80

81 4. Summary Most modern OSs (Windows, UNIX, JVM) provide kernel-level threads via POSIX Pthreads, Win32 thread API, and Java thread API. 81

82 Exercise Write a threading program to sort an n-element array of integers. The sorting task is done by the child thread. The parent thread waits for the child threads to complete its task. The sorted array is output by the parent thread. You can use a sorting algorithm of your choice (e.g., bubble sort, selection sort, insertion sort, and so on). 82

83 Installing and Using Java on Ubuntu Linux I. Installation $ sudo apt-get f install (use this command only when you got error messages) $ sudo apt install pythonsoftware-properties $ sudo add-apt-repository ppa:webupd8team/java $ sudo apt update $ sudo apt install oracle-java8- installer 83

84 Installing and Using Java on Ubuntu Linux II. Usage 1. Compilation $ javac SumApp.java Note: The file SumApp.class is generated 84

85 Installing and Using Java on Ubuntu Linux 2. Execution $ java SumApp 5 The sum of 5 numbers is 15 Note: Load the file SumApp.class for execution 85

86 Installing and Using Java on Ubuntu Linux 3. Check Java version $ java -version java version "1.8.0_101" 86