Lecture 6: Threads

Question 1

Thread

Answer 1

“Lightweight Process”
Abstraction only of CPU (not memory) : basic unit of CPU utilization
Includes: thread ID, PC, registers, stack
shares with other threads of same process: code, data, files

Question 2

Steps for Creating new processes:

Answer 2

1. Allocate Memory
2. Copy Text code
3. Copy Data
4. Copy Stack
5. Copy File Descriptors
6. Copy Registers
7. Copy PC

Question 3

Responsiveness:

Answer 3

interactive program (e.g., multithreaded web browser) can keep running even if one thread (e.g., loading images) blocks

Question 4

Resource Sharing

Answer 4

Code, address space sharing comes for free with threads. For processes, code copying required for former, IPC for latter

Question 5

Economy

Answer 5

Slightly cheaper to context switch

Question 6

Utilization of Multiprocessors->Scalability

Answer 6

Better parallelism: threads of same process can run spread across multiple cores at the same time.

Question 7

Kernel Thread

Answer 7

Managed by OS with multi threaded architecture (Win 7, OS X, Linux, …) similar to a process in the single-threaded system.
- the kernel thread is the unit of execution that is scheduled by the kernel on the CPU

Question 8

User Thread

Answer 8

Implemented with threads library (e.g., Java threads)
relationship to kernel threads:
1. Many-to-one
2. One-to-one
3. Many-to-many

Question 9

Many-to-One

Answer 9

Many user-level threads mapped to single kernel thread

Question 10

Many-to-one Pros and Cons

Answer 10

+ managed by the thread library -> efficient
- one thread blocking causes all to block
(process blocks)
- multiple threads may not run in parallel on
multicore systems -> only one may be in
kernel at a time
- few systems currently use this model

Question 11

One-to-One

Answer 11

Each user-level thread mapped to a kernel thread

Question 12

One-to-One Pros and Cons

Answer 12

+ runs on multi processors
+ more concurrency than many-to-one (no blocking of threads in the same
process)
-number of threads per process sometimes restricted due to overhead of
creating a kernel thread for each user thread

Question 13

Many-to-Many

Answer 13

Allows Many User Level Threads To Be Mapped To Many Kernel Threads

Question 14

Many-to-Many Pros and Cons

Answer 14

+allows the operating system to create a
sufficient number of kernel threads
+can run in a multiprocessor
+ no process blocking

Question 15

Joining Threads

Answer 15

Parent calls child.join()
• Causes parent to wait until child.run() completes
• If child is interrupted (run() doesn’t complete), will throw
exception that parent should catch

Question 16

Cancelling Threads

Answer 16

• Any thread can cancel any other thread it knows about
- how?: invokes interrupt() on thread
• Interrupted thread must be implemented to periodically check its interrupt flag
• - is interrupted ():Returns true or false
• - interrupted ():Returns true or false & clears
interrupt flag
• Thread code specifies what to do upon detecting interrupt flag

Question 17

Multithreading vs. Multiprocessing

Answer 17

• Cheaper context switch

* Much cheaper to fork new threads than to fork new processes

Question 18

User-Level vs. Kernel-Level

Answer 18

• Management of user-level threads via user-level libraries

* Management of kernel-level threads via kernel + interrupts