1. CSS430 Threads Textbook Chapter 4
Instructor: Stephen G. Dame
These slides were adapted from the OSC textbook slides (Silberschatz, Galvin, and Gagne), Professor Munehiro Fukuda and the instructor’s class materials.
CSS430 Operating Systems : Threads

2. WKP 17
“I have not failed. I've just found 10,000 ways that won't work.” – Thomas Edison
CSS430 Operating Systems : Threads

3. Thread Concepts Process-oriented computing Multithreaded computing
code
files
data
code
files
data
thread
code
files
data
process
code
files
data
code
files
data
process
Operating System
Operating System
CSS430 Operating Systems : Threads

4. Single vs. Multithreaded Processes
Carries everything such as an address space, code, data, and files
Heavyweight in terms of creation/termination/context switching
Threads
Shares an address space, code, data and files if they belong to the same process
Lightweight in terms of creation/termination/context switching
Then, what is uniquely carried by each thread?
CSS430 Operating Systems : Threads

5. Threads in Java vs. C/C++
Threads are built-in to the Java API
Portable
JVM uses threads as well for running programs and housekeeping (e.g. garbage collection)
C/C++
Threads not available in core C/C++
Can be implemented via platform dependent thread libraries (e.g. Pthreads)
CSS430 Operating Systems : Threads

6. new Thread to service each Request
Multithreaded Server
new Thread to service each Request
Request
Server
Client
Thread
Thread
Thread
Listen for
additional
requests
CSS430 Operating Systems : Threads

7. Thread Benefits Responsiveness Resource sharing Economy Scalability
Create new threads to process requests while receiving new requests
Resource sharing
Threads share an address space, files, code, and data
Economy
~25-30x faster to create new threads vs. processes
~ 5x faster to context switch
Scalability
Better utilization of multiprocessor architecture
CSS430 Operating Systems : Threads

8. Concurrent Programming (preview of coming attractions...)
“Programming concurrent applications is a difficult and error-prone undertaking” – Dietel**
When thread synchronization is required use the following guidelines (in order of complexity):
Use existing classes from the Java API (e.g. import java.util.concurrent.*)
Use synchronized keyword and Object methods wait, notify and notifyAll
Use Lock and Condition interfaces
** (p.678) Java for Programmers, Deitel & Deitel, 2nd Edition, Prentice Hall, 2011
CSS430 Operating Systems : Threads

9. Benefit: Responsiveness Multithreaded Server
Web Server
Clients
DB1
DB2
CGI
http
pages
CSS430 Operating Systems : Threads

10. Benefit: Deadlock avoidance
Process 2
Process 1
Bounded buffer
send
send
receive
receive
Bounded buffer
A sequence of send and then receive does not work!
Send and receive must be executed concurrently with threads.
CSS430 Operating Systems : Threads

11. Benefit: Utilization of multicore multiprocessor architecture
time = t
time = t + x
Place code, files and data in the main memory.
Distribute threads to each of CPUs, and
Let them execute in parallel.
time = t + 2x
data …
code
files
data
CSS430 Operating Systems : Threads

12. Discussion 1
Why do threads context switch much faster than processes? What data structure must threads carry within their own resources? What data structure can they share? What if we use processes rather than threads for the previous three cases?
a) Responsiveness
b) Deadlock avoidance
c) Utilization of multiprocessor architecture
Provide one programming example of multithreading giving improved performance over a single-threaded solution.
Provide one programming example of multithreading that would not improve performance over a single-threaded solution.
CSS430 Operating Systems : Threads

13. CSS430 ThreadOS
Processes are managed by the real operating system, and cannot be handled by ThreadOS.
Threads are multiple execution entities inside a process
ThreadOS is a process, therefore
ThreadOS executes multiple java application programs as threads.
CSS430 Operating Systems : Threads

14. Simple Thread (ThreadOS)
CSS430 Operating Systems : Threads

15. User and Kernel Threads
User Threads
Thread Management Done by User-Level Threads Library
Examples
- POSIX Pthreads
- Win32 threads
- Java threads
Kernel does not care how many user threads exist.
Kernel Threads
Supported by the Kernel
- Linux
- Windows XP/2000
- Solaris lightweight processes
CSS430 Operating Systems : Threads

16. Many-to-One Model
Many user-level threads mapped to a single kernel thread.
Used on systems that do not support kernel threads.
Examples: Solaris Green Threads, GNU Portable Threads
user thread
PRO
CONS
Fast
Non preemption or version complicated to handle preemption and I/O
No use of MP architecture k
kernel thread
CSS430 Operating Systems : Threads

17. One-to-One Model Each user-level thread maps to kernel thread.
Examples
- Windows NT/XP/2000
- Linux
- Solaris 9 or later
PRO
CONS
1. Everything supported by OS
2. Uses MP architecture
Slower than many-to-one model.
Too many threads do not help
user thread k k k k
kernel thread
CSS430 Operating Systems : Threads

18. Many-to-Many Model
Addresses the shortcomings of the previous two models
Examples
- Windows XP fiber library
- AIX Pthreads
- HP_UX
user thread k k k
kernel thread
CSS430 Operating Systems : Threads

19. Linux Thread Implementation
Process provide by traditional fork() system call
Linux doesn’t distinguish between processes and threads
Each thread is viewed as a process inside the kernel
Linux rather creates tasks using clone()system call
Uses flags to manage resources
no flags  fork()
CSS430 Operating Systems : Threads

20. Lightweight Process (LWP)
A virtual CPU that is available for executing code. *
Can perform independent system calls
Can incur independent page faults
Multiple LWPs, in the same process, can run in parallel on multiple processors
registers
LWP ID
priority
Intr. mask
LWP
“effectively we can say that threads and light weight processes are same. It’s just that thread is a term that is used at user level while light weight process is a term used at kernel level.” **
* Multithreaded Programming with JAVA™ Technology, Lewis/Berg
** What are Linux Processes, Threads, Light Weight Processes, and Process State
CSS430 Operating Systems : Threads

21. Process Structure
Kernel schedules each light-weight process separately.
Traditional UNIX Process
Multi-threaded Process
Directory Entry
UID GID EUID EGID
Process ID
TTY
Directory Entry
UID GID EUID EGID
Process ID
TTY
Signal Dispatch
Table
Memory Map
Signal Dispatch
Table
Memory Map
LWP1
LWP2 1 2 3
stdin
stdout
stderr
File Descriptors 1 2 3
stdin
stdout
stderr
File Descriptors
priority
Intr. mask
registers
CPU Status
CSS430 Operating Systems : Threads

22. Thread Structure Thread library runs in a user space.
Process
JVM
Java Threads
Thread library runs in a user space.
All threads shared the same address space.
Each thread maintains its own information and stack space.
Once a thread is mapped to a LWP, it runs on a CPU.
thread info
Thread3
stack
red zone
thread info
Thread2
stack
red zone
thread info
Thread1
stack
Thread1
Thread2
Thread3
red zone
heap
Thread3
code + global data
Pthreads
Win32 threads
Thread to LWP mapping
User mode
Kernel mode
LWP1
LWP2
CSS430 Operating Systems : Threads

23. Pthreads
A POSIX standard (IEEE c) 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)
CSS430 Operating Systems : Threads

24. Pthreads (in C)
CSS430 Operating Systems : Threads

25. Threads (Java) MyThread.java Compile and run ThreadFunc.java
CSS430 Operating Systems : Threads

26. Java Threads Java threads may be created one of 2 ways:
Extending thread class
Implementing the Runnable interface
CSS430 Operating Systems : Threads

27. Extending thread class
Worker1.java
First.java {Thread creation}
CSS430 Operating Systems : Threads

28. Runnable Interface Worker2.java Second.java {Thread creation}
CSS430 Operating Systems : Threads

29. Java Threads Producer-Consumer
CSS430 Operating Systems : Threads

30. Java Threads Producer
CSS430 Operating Systems : Threads

31. Java Threads Consumer
CSS430 Operating Systems : Threads

32. Java Threads Utilities
CSS430 Operating Systems : Threads

33. Java Thread Management
setPriority( ) – changes this thread’s priority.
sleep() – puts the currently running thread to sleep for a specified amount of time.
suspend() – suspends execution of the currently running thread.
resume() – resumes execution of a suspended thread.
stop() – stops execution of a thread.
For more information, visit:
JAVA SE7 API THREAD CLASS
Suspend, resume, and stop are currently deprecated in the specification.
CSS430 Operating Systems : Threads

34. Thread Pools Key Benefits of TPs are:
Servicing incoming request is faster with existing threads than creating new threads
Thread Pools limit the total number of threads in the system.
CSS430 Operating Systems : Threads

35. Thread Pools PrintTask (worker example)
CSS430 Operating Systems : Threads

36. Thread Creation w/o Pools Driver (TaskCreator)
CSS430 Operating Systems : Threads

37. Thread Creation using Pools Driver (TaskExecutor)
* Better way to manage programs with many threads!
CSS430 Operating Systems : Threads

38. Java Thread States
CSS430 Operating Systems : Threads

39. Thread Life-cycle UML State Model
New
acquire lock, interrupt,
I/O completes
runnable
enter synchronized
statement
notify
notifyAll
Interval expires
Notify
notifyAll
task completes
sleep
wait
issue I/O request
wait
waiting
timed waiting
terminated
blocked
CSS430 Operating Systems : Threads

40. Rewrite this program in Java.
Exercises
(no-turn in) build and run all code snippets provided in the slides.
(turn-in) Exercise A Pthread program that performs the summation function was provided in Section
Rewrite this program in Java.
...for next Monday midnight deadline 
Note: more homework will be added to Thursday night’s lecture on scheduling
CSS430 Operating Systems : Threads