1. CSS 430: Operating Systems - Threads
Lecture 7: Threads
Joe McCarthy
CSS 430: Operating Systems - Threads

2. CSS 430: Operating Systems - Threads
Outline
More examples
testpipe3.cpp
Chapter 4: Threads
Assignment 2: Threads & Scheduling
Next time:
Chapter 5: CPU Scheduling
CSS 430: Operating Systems - Threads

3. CSS 430: Operating Systems - Threads
More examples
testpipe3.cpp
uw1-320-lab: /usr/apps/CSS430/examples
Uses
fork(), pipe(), dup2()
echo, cat
Designed to
Echo it’s first argument through a pipe
[…]$ ./testpipe3 hello
hello
… and then hang
CSS 430: Operating Systems - Threads

4. CSS 430: Operating Systems - Threads
/* includes omitted from this excerpt */
int main( int argc, char** argv ) {
int fd[2];
int pid; // only need one pid (why?)
assert(argc == 2);
if ( pipe(fd) < 0 ) {
perror( "pipe" ); exit( EXIT_FAILURE );
} else if ( ( pid = fork() ) < 0 ) {
perror( "fork" ); exit( EXIT_FAILURE );
} else if ( pid > 0 ) { // this is the parent
wait( NULL ); exit( EXIT_SUCCESS );
} else if ( pid > 0 ) { // this is [still] the child
dup2( fd[0], 0 ); // copy read-end of pipe to STDIN
close( fd[1] ); // close write-end of pipe (not needed)
execlp( "cat", "cat", NULL );
} else { // this is the grand-child
close( fd[0] ); // close read-end of pipe (not needed)
dup2( fd[1], 1 ); // copy write-end of pipe to STDOUT
execlp( "echo", "echo", argv[1], NULL ); }
CSS 430: Operating Systems - Threads

5. CSS 430: Operating Systems - Threads
Chapter 4: Threads
Overview
Multithreading Models
Thread Libraries
Threading Issues
Operating System Examples
Windows XP Threads
Linux Threads
Material derived, in part, from Operating Systems Concepts with Java, 8th Ed. © 2009 Silberschatz, Galvin & Gagne
CSS 430: Operating Systems - Threads

6. Single and Multithreaded Processes
CSS 430: Operating Systems - Threads

7. CSS 430: Operating Systems - Threads
Benefits
Responsiveness
Resource Sharing
Economy
Scalability
CSS 430: Operating Systems - Threads

8. Multicore Programming
Multicore systems putting pressure on programmers, challenges include:
Dividing activities
Balance
Data splitting
Data dependency
Testing and debugging
CSS 430: Operating Systems - Threads

9. Multithreaded Server Architecture
CSS 430: Operating Systems - Threads

10. Concurrent Thread Execution
CSS 430: Operating Systems - Threads

11. CSS 430: Operating Systems - Threads
User Threads
Thread management done by user-level threads library
Three primary thread libraries:
POSIX Pthreads
Win32 threads
Java threads
CSS 430: Operating Systems - Threads

12. CSS 430: Operating Systems - Threads
Kernel Threads
Supported by the Kernel
Examples
Windows XP/2000
Solaris
Linux
Tru64 UNIX
Mac OS X
CSS 430: Operating Systems - Threads

13. Multithreading Models
Many-to-One
One-to-One
Many-to-Many
CSS 430: Operating Systems - Threads

14. CSS 430: Operating Systems - Threads
Many-to-One
Many user-level threads mapped to single kernel thread
Examples:
Solaris Green Threads
GNU Portable Threads
CSS 430: Operating Systems - Threads

15. CSS 430: Operating Systems - Threads
Many-to-One Model
CSS 430: Operating Systems - Threads

16. CSS 430: Operating Systems - Threads
One-to-One
Each user-level thread maps to kernel thread
Examples
Windows NT/XP/2000
Linux
Solaris 9 and later
CSS 430: Operating Systems - Threads

17. CSS 430: Operating Systems - Threads
One-to-one Model
CSS 430: Operating Systems - Threads

18. CSS 430: Operating Systems - Threads
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
CSS 430: Operating Systems - Threads

19. CSS 430: Operating Systems - Threads
Many-to-Many Model
CSS 430: Operating Systems - Threads

20. CSS 430: Operating Systems - Threads
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
CSS 430: Operating Systems - Threads

21. CSS 430: Operating Systems - Threads
Two-level Model
CSS 430: Operating Systems - Threads

22. CSS 430: Operating Systems - Threads
Thread Libraries
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
CSS 430: Operating Systems - Threads

23. CSS 430: Operating Systems - Threads
Pthreads
May be user-level or kernel-level
A POSIX standard (IEEE c) API for thread creation & synchronization
API specifies behavior of the thread library, implementation varies
Common in UNIX operating systems (Solaris, Linux, Mac OS X)
CSS 430: Operating Systems - Threads

24. Java Threads Java threads are managed by the JVM
1 process, 1+ threads
Java threads may be created by:
Extending the Thread class
Implementing the Runnable interface
public class MyShell extends Thread { …
void run() { }
/usr/apps/CSS430/examples/threads
CSS 430: Operating Systems - Threads

25. Java Threads - Producer-Consumer
Main driver: Factory.java
Shared memory via queue variable
Instantiates & starts 2 Threads
import java.util.Date;
public class Factory {
public static void main( String[] args ) {
// create the message queue
Channel<Date> queue = new MessageQueue<Date>();
// create the producer and consumer threads
Thread producer = new Thread( new Producer(queue) );
Thread consumer = new Thread( new Consumer(queue) );
// start the threads
producer.start();
consumer.start(); }
/usr/apps/CSS430/examples/threads
CSS 430: Operating Systems - Threads

26. Java Threads - Producer-Consumer
Shared memory via abstract data type: Channel.java
public interface Channel<E> {
public void send(E item);
public E receive(); }
/usr/apps/CSS430/examples/threads
CSS 430: Operating Systems - Threads

27. Java Threads - Producer-Consumer
Implementation of abstract data type: MessageQueue.java
import java.util.Vector;
public class MessageQueue<E> implements Channel<E> {
private Vector<E> queue;
public MessageQueue() {
queue = new Vector<E>(); }
public void send( E item ) {
queue.addElement( item ); // add to tail (end)
public E receive() {
if ( queue.size() == 0 )
return null;
else // remove from head (front)
return queue.remove( 0 );
/usr/apps/CSS430/examples/threads
CSS 430: Operating Systems - Threads

28. Java Threads - Producer-Consumer
Implementation of producer thread: Producer.java
import java.util.Date;
class Producer implements Runnable {
private Channel<Date> queue;
public Producer( Channel<Date> queue ) {
this.queue = queue; }
@SuppressWarnings("unchecked")
public void run() {
Date message;
while ( true ) {
SleepUtilities.nap();
message = new Date(); // produce an item
System.out.println( "Producer produced " + message );
queue.send(message); // enter it into the buffer
/usr/apps/CSS430/examples/threads
CSS 430: Operating Systems - Threads, Scheduling, Assignment 2

29. Java Threads - Producer-Consumer
Implementation of consumer thread: Consumer.java
import java.util.Date;
class Consumer implements Runnable {
private Channel<Date> queue;
public Consumer( Channel<Date> queue ) {
this.queue = queue; }
@SuppressWarnings("unchecked")
public void run() {
Date message;
while ( true ) {
SleepUtilities.nap();
System.out.println( "Consumer wants to consume." );
message = queue.receive(); // consume an item from buffer
if ( message != null )
System.out.println( "Consumer consumed " + message );
/usr/apps/CSS430/examples/threads
CSS 430: Operating Systems - Threads, Scheduling, Assignment 2

30. CSS 430: Operating Systems - Threads
Java Thread States
CSS 430: Operating Systems - Threads

31. CSS 430: Operating Systems - Threads
Threading Issues
Semantics of fork() and exec() system calls
Thread cancellation of target thread
Asynchronous or deferred
Signal handling
Thread pools
Thread-specific data
Scheduler activations
CSS 430: Operating Systems - Threads

32. Semantics of fork() and exec()
Does fork() duplicate only the calling thread or all threads?
CSS 430: Operating Systems - Threads

33. CSS 430: Operating Systems - Threads
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
CSS 430: Operating Systems - Threads

34. CSS 430: Operating Systems - Threads
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
CSS 430: Operating Systems - Threads

35. CSS 430: Operating Systems - Threads
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.
CSS 430: Operating Systems - Threads

36. CSS 430: Operating Systems - Threads
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)
CSS 430: Operating Systems - Threads

37. 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
CSS 430: Operating Systems - Threads

38. Operating System Examples
Windows XP Threads
Linux Thread
CSS 430: Operating Systems - Threads 38

39. CSS 430: Operating Systems - Threads
Windows XP Threads
CSS 430: Operating Systems - Threads

40. CSS 430: Operating Systems - Threads
Linux Threads
CSS 430: Operating Systems - Threads

41. CSS 430: Operating Systems - Threads
Windows XP Threads
Implements the one-to-one mapping, kernel-level
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)
CSS 430: Operating Systems - Threads

42. CSS 430: Operating Systems - Threads
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)
CSS 430: Operating Systems - Threads

43. CSS 430: Operating Systems - Threads
For next time
Readings
Chapter 5: CPU Scheduling
CSS 430: Operating Systems - Threads