ECE3055 Computer Architecture and Operating Systems Lecture 12 Threads

1
ECE3055 Computer Architecture and Operating
SystemsLecture 12 Threads

• Prof. Hsien-Hsin Sean Lee
• School of Electrical and Computer Engineering
• Georgia Institute of Technology

2
Single and Multithreaded Processes
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
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 processs
  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
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

Processs address space
TCB for thread1
pc sp State Registers
Reserved
DLLs
Stack thread 1
Stack thread 2
TCB for thread2
pc sp State Registers
Heap
Initialized data
CODE
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
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
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
Multithreading Models

• Many-to-One
• One-to-One
• Many-to-Many

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
Many-to-One Model
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
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
• 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
Many-to-Many Model
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
Two-level (or Combined) Model
18
Threading Issues

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

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

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
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
Scheduler Activations

• Both MM 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
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
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,argv1)
/ 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 gt 0) for (i 1 i lt upper i)
sum i pthread_exit(0)
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
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
Java Threads

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

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
The Runnable Interface

• public interface Runnable
• public abstract void run()

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
Java Thread States
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
Thread Cancellation
Thread thrd new Thread (new InterruptibleThread(
)) Thrd.start() . . . // now interrupt
it Thrd.interrupt()
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
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
Thread Specific Data
class Worker implements Runnable private
static Service provider public void run()
provider.transaction()
System.out.println(provider.getErrorCode())

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