CH 4 - Threads

Chapter 4: Threads
Operating System Concepts – 9th Edition Silberschatz, Galvin and Gagne ©2013
Introduction
 Multitasking is the feature that allows your computer to run two or more programs
concurrently and Multithreading is a specialized form of multitasking
 Two types of multitasking:
 process-based  handles the concurrent execution of programs
 thread-based handles concurrent execution of pieces of the same program
 A thread is also called a lightweight process. Threads provide a way to improve
application performance through parallelism.
 A multithreaded program contains two or more parts that can run concurrently.
 Each part of such a program is called a thread, and each thread defines a
separate path of execution.
 A thread is a semi-process, that has its own stack, and executes a given piece of
code
 Unlike a real process, the thread normally shares its memory with other threads
Operating System Concepts – 9th Edition 4.2 Silberschatz, Galvin and Gagne ©2013
Threads
 Thread vs process:
 Thread is the segment of a process means a process can have
multiple threads and these multiple threads are contained within
a process.
 a Thread of execution is the smallest sequence of programmed instructions that
can be managed independently
 Thread- a light-weight process executing in the address space of the process
 Thread – a separately schedulable sequential execution stream within a
process
 A Thread Group is a set of threads all executing inside the same process
 Multiple threads can run in same address space so can access the same global
variables, same heap memory, same set of file descriptors, etc.
 Why threads?
 Process creation is expensive
 Save memory space
Threads…
Single-threaded Process Multiplethreaded Process

Threads of
Execution
Single instruction stream Multiple instruction stream

Common
Address Space
Threads…
• Thread-control-block
Single and Multithreaded Processes
Motivation
 Most modern applications are multithreaded

 Threads run within application
 Multiple tasks with the application can be implemented by
separate threads
 Update display
 Fetch data
 Spell checking
 Answer a network request
 Process creation is heavy-weight while thread creation is
light-weight
 Can simplify code, increase efficiency
Multithreaded Server Architecture
Benefits
 Responsiveness – may allow continued execution if part of

process is blocked, especially important for user interfaces
 Resource Sharing – threads share resources of process, easier
than shared memory or message passing
 Economy – cheaper than process creation, thread switching
lower overhead than context switching
 Scalability – process can take advantage of multiprocessor
architectures – Single threaded can run only on one core
irrespective of no. of processors
Multicore Programming
 Multicore or multiprocessor systems putting pressure on

programmers, challenges include:
 Dividing activities
 Balance
 Data splitting
 Data dependency
 Testing and debugging
 Parallelism implies a system can perform more than one task
simultaneously
 Concurrency supports more than one task making progress
 Single processor / core, scheduler providing concurrency
Concurrency vs. Parallelism
 Concurrent execution on single-core system:
 Parallelism on a multi-core system:
Multicore Programming (Cont.)
 Types of parallelism
 Data parallelism – distributes subsets of the same data
across multiple cores, same operation on each
 Task parallelism – distributing threads across cores, each
thread performing unique operation
User Threads and Kernel Threads
 User threads - management done by user- without kernel support
 Three primary thread libraries:
 POSIX Pthreads
 Windows threads
 Java threads
 Kernel threads - Supported and managed directly by the Kernel
 Examples – virtually all general purpose operating systems, including:
 Windows
 Solaris
 Linux
 Tru64 UNIX
 Mac OS X
 Solaris 2 supports both
Kernel Level Thread User Level Thread
Multithreading Models
 Many-to-One
 One-to-One
 Many-to-Many
Many-to-One
 Many user-level threads mapped to

single kernel thread
 One thread blocking causes all to block
 Multiple threads may not run in parallel
on multicore system because only One
thread can access the kernel at a time
 Scheduling is fair among processes
 Few systems currently use this model
 Examples:
 POSIX pthread
 Solaris Green Threads
 GNU Portable Threads
One-to-One
 Each user-level thread maps to kernel thread
 Creating a user-level thread creates a kernel
thread
 More concurrency than one-to-many if one
thread makes a blocking call
 Number of threads per process sometimes
restricted due to overhead
 Examples
 Windows
 Linux
 Solaris 9 and later
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
 Number of Kernal level threads are <=
number of user level threads
 No true concurrency
 Kernel schedule another thread if a
user level thread makes a blocking
system call
 Solaris prior to version 9
 Windows with the ThreadFiber
package
Operations on threads
 Creating Threads
 pthread_create (thread, attr, start_routine, arg)
 Attrstack size and scheduling information
 Terminating Thread Execution
 pthread_exit (status)
 Passing Arguments to Threads
 Joining Threads
 pthread_join (threadid, status)  blocks the calling thread until the specified threadid
thread terminates
 Detaching / Undetaching Threads
 pthread_detach (threadid)
 POSIX is a standardized programming interface

 POSIX threads or pthreads
 Pthreads are defined as a set of C language programming types and procedure calls

CH 4 - Threads

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

CH 4 - Threads

Uploaded by

Copyright:

Available Formats

Chapter 4: Threads

Single-threaded Process Multiplethreaded Process

Single instruction stream Multiple instruction stream

 Most modern applications are multithreaded

 Responsiveness – may allow continued execution if part of

 Multicore or multiprocessor systems putting pressure on

 Parallelism on a multi-core system:

 Many user-level threads mapped to

 POSIX is a standardized programming interface

You might also like