Transcript Threads

Chapter 2.5 : Threads





Process concept 
Process scheduling 
Interprocess communication 
Deadlocks
Threads
1
Threads
These lecture notes have been adapted from
 How to program with threads
An introduction to multithreaded programming

By Bil Lewis and Daniel J. Berg
and
Tanenbaum slides
2
Processes & Threads


Processes and threads are related concepts
A process is a kernel-level entity


Process structure can only be accessed through
system calls
A thread (or a lightweight process) is a user-level
entity
The thread structure is in user space
 It is accessed directly with the thread library calls,
which are just normal user-level functions
(threads do not use system calls)

3
Single vs. Multiple Threads of
Execution
Single Thread
Start
Multiple Threads
Start
Edit Document
Edit Document
Print Document
Print Document
End
End
4
Thread Usage (1)
A word processor with three threads
5
Thread Usage (2)
A multithreaded Web server
6
Thread Usage (3)

Rough outline of code for previous slide
(a) Dispatcher thread
(b) Worker thread
7
The Classical Thread Model (1)
(a) Three processes each with one thread
(b) One process with three threads
8
The Thread Model (2)


(Per process items) Items shared by all threads in a
process
(Per thread items) Items private to each thread
9
The Thread Model (3)
Each thread has its own stack
10
Process and Thread Data
Structures
TCB1
Code
TCB2
TCB3
Data
Stack
User Space
Kernel Space
PCB
11
Characteristics of Threads

The TCB (thread control block) consist of

program counter

register set

stack space
Thus the TCB is a reduced PCB

A traditional process is equal to a task with one
thread

All threads in a process share the state of that
process
12
Characteristics of Threads
(Cont.)

They reside in the exact same memory space (user
memory), see the same code and data

When one thread alters a process variable (say, the
working directory), all the others will see the change
when they next access it

If one thread opens a file to read it, all the other
threads can also read from it.
13
Characteristics of Threads
(Cont.)

Because no system calls are involved, threads are
fast

There are no kernel structures affected by the
existence of threads in a program, so no kernel
resources are consumed -- threads are cheap

The kernel doesn't even know that threads exist
14
Thread Scheduling (1)
Possible scheduling of user-level threads


50-msec process quantum
threads run 5 msec/CPU burst
15
Thread Scheduling (2)
Possible scheduling of kernel-level threads


50-msec process quantum
threads run 5 msec/CPU burst
16
Threads of a Task
Threads
Program
Counter
Code segment
Task
Data
segment
17
Implementing Threads in User Space
A user-level threads package
18
Implementing Threads in the Kernel
A threads package managed by the kernel
19
Hybrid Implementations
Multiplexing user-level threads onto kernel- level
threads
20
Some Benefits of Writing
Multithreaded Programs:
 Performance gains from multiprocessing
hardware (parallelism)
 Increased application throughput
 Increased application responsiveness
 Enhanced process-to-process
communications
21
Parallellism

Different threads can run on different
processors simultaneously with no special
input from the user and no effort on the part
of the programmer
22
Throughput

When a traditional, single-threaded program
requests a service from the operating system,
it must wait for that service to complete,
often leaving the CPU idle

Multithreading provides progress even
though one or more threads wait for an event
as long as other threads are active
23
Responsiveness

Blocking one part of a process need not block the
whole process. Single-threaded applications that do
something lengthy when a button is pressed typically
display a "please wait" cursor and freeze while the
operation is in progress

If such applications were multithreaded, long
operations could be done by independent threads,
allowing the application to remain active and making
the application more responsive to the user
24
Communications

An application that uses multiple processes to
accomplish its tasks can be replaced by an
application that uses multiple threads to accomplish
those same tasks

Processes-to-process
communication
through
traditional IPC (interprocess communications)
facilities (e.g., pipes or sockets)

The threaded application can use the inherently
shared memory of the process
25