chapter 2 5 threads n.
Skip this Video
Loading SlideShow in 5 Seconds..
Chapter 2.5 : Threads PowerPoint Presentation
Download Presentation
Chapter 2.5 : Threads

Loading in 2 Seconds...

play fullscreen
1 / 25

Chapter 2.5 : Threads - PowerPoint PPT Presentation

  • Uploaded on

Chapter 2.5 : Threads. Process concept  Process scheduling  Interprocess communication  Deadlocks  Threads. 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

I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
Download Presentation

PowerPoint Slideshow about 'Chapter 2.5 : Threads' - jakeem-barlow

An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
chapter 2 5 threads
Chapter 2.5 : Threads
  • Process concept 
  • Process scheduling 
  • Interprocess communication 
  • Deadlocks
  • 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


  • Tanenbaum slides
processes threads
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)
single vs multiple threads of execution



Edit Document

Print Document

Edit Document

Print Document



Single vs. Multiple Threads of Execution

Multiple Threads

Single Thread

thread usage 1
Thread Usage (1)

A word processor with three threads

thread usage 2
Thread Usage (2)

A multithreaded Web server

thread usage 3
Thread Usage (3)
  • Rough outline of code for previous slide

(a) Dispatcher thread

(b) Worker thread

the classical thread model 1
The Classical Thread Model (1)

(a) Three processes each with one thread

(b) One process with three threads

the thread model 2
The Thread Model (2)
  • (Per process items) Items shared by all threads in a process
  • (Per thread items) Items private to each thread
the thread model 3
The Thread Model (3)

Each thread has its own stack

process and thread data structures








Process and Thread Data Structures

User Space

Kernel Space

characteristics of threads
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
characteristics of threads cont
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.
characteristics of threads cont1
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
thread scheduling 1
Thread Scheduling (1)

Possible scheduling of user-level threads

  • 50-msec process quantum
  • threads run 5 msec/CPU burst
thread scheduling 2
Thread Scheduling (2)

Possible scheduling of kernel-level threads

  • 50-msec process quantum
  • threads run 5 msec/CPU burst
threads of a task
Threads of a Task



Program Counter

Data segment

Code segment

implementing threads in user space
Implementing Threads in User Space

A user-level threads package

implementing threads in the kernel
Implementing Threads in the Kernel

A threads package managed by the kernel

hybrid implementations
Hybrid Implementations

Multiplexing user-level threads onto kernel- level threads

some benefits of writing multithreaded programs
Some Benefits of Writing Multithreaded Programs:
  • Performance gains from multiprocessing hardware (parallelism)
  • Increased application throughput
  • Increased application responsiveness
  • Enhanced process-to-process communications
  • Different threads can run on different processors simultaneously with no special input from the user and no effort on the part of the programmer
  • 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
  • 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
  • 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