Post on 19-Dec-2015
Chapter 4: Threads
• Overview thread — a fundamental unit of CPU
utilization that forms the basis of multithreaded computer systems
• Thread Libraries Pthreads Nachos threads
Logical View of Threads
• Threads associated with a process
P1
shsh sh
foo
T1
Process hierarchyA process
T2T4
T5 T3
shared code, dataand kernel context
Benefits of multi-threading
• Responsiveness
• Resource Sharing Shared memory
• Economy
• Scalability Explore multi-core CPUs
Thread Abstraction
• Infinite number of processors• Threads execute with variable speed
Programs must be designed to work with any schedule
Concurrent Thread Execution
• Two threads run concurrently (are concurrent) if their logical flows overlap in time
• Otherwise, they are sequential (we’ll see that processes have a similar rule)
• Examples: Concurrent: A & B, A&C Sequential: B & C
Time
Thread A Thread B Thread C
Execution Flow
Concurrent execution on a single core system
Parallel execution on a multi-core system
Difference between Single and Multithreaded ProcessesShared memory access for code/dataSeparate control flow -> separate stack/registers
Threads vs. Processes
• How threads and processes are similar Each has its own logical control flow Each can run concurrently Each is context switched
• How threads and processes are different Threads share code and data, processes
(typically) do not Threads are somewhat cheaper than
processes with less overhead
Thread Libraries
• Thread library provides programmer with API for creating and managing threadsPthreads Java threadsOS-specific threads
–Nachos for class proj.
Pthreads
• provided either as user-level or kernel-level• A POSIX standard (IEEE 1003.1c) API for thread
creation and synchronization• Common in UNIX OS (Linux, Mac OS X).
In CSIL, compile a c program with gcc -lpthread
Posix Threads (Pthreads) Interface
• Creating and reaping threads pthread_create, pthread_join
• Determining your thread ID pthread_self
• Terminating threads pthread_cancel, pthread_exit exit [terminates all threads] , return [terminates current
thread]• Synchronizing access to shared variables
pthread_mutex_init, pthread_mutex_[un]lock pthread_cond_init, pthread_cond_[timed]wait
Example of Pthreads
#include <pthread.h>
#include <stdio.h>
void *PrintHello(void * id){
printf(“Thread%d: Hello World!\n", id);
}
void main (){
pthread_t thread0, thread1;
pthread_create(&thread0, NULL, PrintHello, (void *) 0);
pthread_create(&thread1, NULL, PrintHello, (void *) 1);
}
Example of Pthreads with join
#include <pthread.h>
#include <stdio.h>
void *PrintHello(void * id){
printf(“Thread%d: Hello World!\n", id);
}
void main (){
pthread_t thread0, thread1;
pthread_create(&thread0, NULL, PrintHello, (void *) 0);
pthread_create(&thread1, NULL, PrintHello, (void *) 1);
pthread_join(thread0, NULL);
pthread_join(thread1, NULL);
}
Execution of Threaded “hello, world”
main thread
peer thread
main thread waits for peer thread to terminate
exit() terminates
main thread and any peer threads
call Pthread_create()
call Pthread_join()
Pthread_join() returns
printf()
(peer threadterminates)
Java Threads
• Java threads are managed by the JVM• Java threads may be created by extending
Thread class Thread class
– run, start methods– yield, join– sleep
• Synchronization synchronized methods & objects wait/notify/notifyAll conditions
Java Threads: Exampleclass MyThread extends Thread {
private String name;
public MyThread(String name) {this.name = name;
}
public void run() {for (;;) {
System.out.println(name + ": hello world");}
}}public class Main2 {
public static void main(String [] args) {MyThread t1 = new MyThread("thread1");MyThread t2 = new MyThread("thread2");t1.start(); t2.start();
}}
Java Threads: example outpout
thread2: hello world
thread2: hello world
thread2: hello world
thread2: hello world
thread2: hello world
thread2: hello world
thread2: hello world
thread2: hello world
thread1: hello world
thread2: hello world
thread1: hello world
thread2: hello world
thread2: hello world
thread1: hello world
thread2: hello world
thread2: hello world
Nachos Threads
• class Thread{
public:
Thread (char *name);
~Thread();
void Fork( void (*Func)( int), int arg);
void Yield();
void Finish();
}
Nachos Threads for 170 OS Project
C++ methods supported:• Thread(char *Name). Create a thread.• Fork(VoidFunctionPtr func, int arg). A thread
starts to execute a function.• Yield(). Suspend the calling thread and the
system selects a new one for execution.• Sleep(). Suspend the current thread, change
its state to BLOCKED, and remove it from the ready list
• Finish()
main (){ Thread *t1 =new Thread("thread1"); Thread *t2= new Thread("thread2");
t1->Fork(SimpleFunc, 1); t2->Fork(SimpleFunc, 2);
SimpleFunc(3);}
SimpleFunc(int i){ printf(“Hello %d\n”, i); currentThread->Yield();}
Example of Nacho Threads
Start to fork and execute a function in each child thread.
Function executed by threads
Create 2 new thread data structure
Parent executes the same function
Implementing threads
• Thread_fork(func, args) Allocate thread control block Allocate stack Build stack frame for base of stack (stub) Put func, args on stack Put thread on ready list Will run sometime later (maybe right away!)
• stub(func, args): Call (*func)(args) Call thread_exit()
• Thread switching during scheduling Save registers on old stack Switch to new stack, new thread Restore registers from new stack
Types of Threads: Kernel vs user-level
Kernel Threads• Recognized and supported by the OS Kernel• OS explicitly performs scheduling and context
switching of kernel threads
• Linux, MacOS, Windows
User-level Threads
• Thread management done by user-level threads library OS kernel does not know/recognize there are
multiple threads running in a user program. The user program (library) is responsible for
scheduling and context switching of its threads.
• Examples: Java threads
Summary: Process vs Thread• Processes have two parts
Threads (Concurrency) Address Spaces (Protection)
• Concurrency accomplished by multiplexing CPU Time: Unloading current thread (PC, registers) Loading new thread (PC, registers) Such context switching may be voluntary (yield(), I/O
operations) or involuntary (timer, other interrupts)• Protection accomplished restricting access:
Memory mapping isolates processes from each other Dual-mode for isolating I/O, other resources
• Various Textbooks talk about processes When this concerns concurrency, really talking about
thread portion of a process When this concerns protection, talking about address
space portion of a processJohn Kubiatowicz (http://cs162.eecs.Berkeley.edu)