concurrency processes and threads n.
Skip this Video
Loading SlideShow in 5 Seconds..
Concurrency, Processes and Threads PowerPoint Presentation
Download Presentation
Concurrency, Processes and Threads

Loading in 2 Seconds...

play fullscreen
1 / 26

Concurrency, Processes and Threads - PowerPoint PPT Presentation

  • Uploaded on

Concurrency, Processes and Threads. Concurrency. The appearance that multiple actions are occurring at the same time On a uni-processor, something must make that happen A collaboration between the OS and the hardware

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 'Concurrency, Processes and Threads' - cricket

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
  • The appearance that multiple actions are occurring at the same time
  • On a uni-processor, something must make that happen
    • A collaboration between the OS and the hardware
  • On a multi-processor, the same problems exist (for each CPU) as on a uni-processor
  • Combines multiplexing types:
  • Space-multiplexing - Physical Memory
  • Time-multiplexing - Physical Processor




multiprogramming 2
  • Multiprogramming defined
    • N programs apparently running simultaneously
      • space-multiplexed in executable memory
      • time-multiplexed across the central processor
  • Why it's desired
    • Greater throughput (work done per unit time)
    • More work occurring at the same time
  • Resources required
    • CPU
    • Memory
the cpu
  • Instruction cycles
    • Access memory and/or registers
    • Sequential flow via "instruction register"
    • One instruction-completion at a time
      • (Pipelines only increase the # of completions per time unit). They are still sequential!
  • Modes of execution
    • Privileged (System)
    • Non-privileged (User )
  • Sequential addressing (0 – n)
  • Partitioned
    • System
      • Inaccessible by user programs
    • User
      • Partitioned for multiple users
      • Accessible by system programs
processes 1
  • A Process is
    • A running program & its address space
    • A unit of resource management
    • Independent of other processes
      • NO sharing of memory with other processes
      • May share files open at Fork time
  • One program may start multiple processes, each in its own address space
processes 2 abstraction
Processes-2 Abstraction




Instruction stream


Data stream

Operating System





Process & Address Space




Abstract Machine Environment

Address Space

processes 3
  • The Process life-cycle
    • Creation
      • User or scheduled system activation
    • Execution
      • Running
        • Performing instructions (using the ALU)
      • Waiting
        • Resources or Signals
      • Ready
        • All resources available except memory and ALU
    • Termination
      • Process is no longer available
processes 4
  • Space multiplexing
    • Each process operates in its own"address space"
    • Address space is a sequence of memory locations (addresses) from 0 to 'n' as seen by the application
    • Process addresses must be "mapped" to real addresses in the real machine
  • More on this later
processes 5
  • Time multiplexing
    • Each process is given a small portion of time to perform instructions
    • O/S controls the time per process and which process gets control next
      • Many algorithms for this
      • No rules (from user's/programmer's view) on which process will run next or for how long
      • Some OS's dynamically adjust both time and sequence
processes 7
  • FORK (label)
    • Starts a process running from the labeled instruction – gets a copy of address space
  • QUIT()
    • Process terminates itself
  • JOIN (count) (an atomic operation)
    • Merges >=2 processes
    • Really more like "quit, unless I'm the only process left"
threads 1
  • A unit of execution withina process(often called a lightweight process – an "lwp")also called a "task"
  • Share address space, data and devices with other threads within the process
  • Private stack, status (IC, state, etc)
  • Multi-threading
    • >1 thread per process
  • Limited by system to some max #
    • Per system
    • Per process
thread models
Thread Models



Classic UNIX

WinXX, Solaris, Linux, OS/2

thread models1
Thread models
  • Many to One (n ULT's - 1 KLT)
    • ULT block= process block
  • One to One
    • One ULT =distinct Kernel Thread.
    • Thread block != process block, so more concurrency.
    • Drawback: kernel is involved (context switching overhead)
  • Many to Many
    • Time multiplexing: m ULT's >=n KLT's
    • True concurrency limited (scheduling ULT's)
threads 2
  • Several thread API's
    • Solaris: kernel-level threads & pthreads
    • Windows: kernel-level threads & pthreads
    • OS/2: kernel-level threads
    • Posix (pthreads) – full set of functions
      • #include <pthread.h> // for C, C++
      • Allows porting without re-coding
    • Java threads implemented in JVM, independent of OS support
      • Like multiprogramming implementation in Win3.1
      • Uses underlying kernel support where available
threads 3
  • Windows (native)

CreateThread( DWORD dwCreateFlags = 0, UINT nStackSize = 0, LPSECURITY_ATTRIBUTES lpSecurityAttrs = NULL );

  • Solaris (native) - not discussed here
  • POSIX (Linux, Solaris, Windows)

iret1 = pthread_create( &thread1, NULL, (void*) &print_message_function, (void*) message1);

  • Pthreads
    • same behavior as POSIX
    • Almost identical API as POSIX
    • Implemented via Windows API (One to One model)
threads 4
  • Advantages of kernel-supported threads:
    • May request resources with or without blocking on the request
    • Blocked thread does NOT block other threads
    • Inexpensive context switch
    • Utilize MP architecture
  • Thread library for user threads is in user space
    • Thread library schedules user threads onto LWP’s
    • LWP’s are:
      • implemented by kernel threads
      • scheduled by the kernel.
solaris threads
Solaris Threads
  • Supports threads at boththe kernel and user levels, + symmetric multiprocessing, and real-time scheduling.
  • Implements the pthread API, + userlevel threads in a thread library with API’s for thread creation & management based on Solaris threads
java thread creation method 1
Java Thread Creation, Method 1

import java.lang.*;public class myCounter extends Thread {                        public void run() 

//overrides                            {                      ....                    }}

  • This creates an extension of the Thread class
now create the thread
Now create the thread

public class XYZ


public static void main(String args[])


myCounter runner = new myCounter();

runner.start(); // this is thread 2

System.out.println(“I am the main thread”);



java thread creation method 2
Java Thread Creation, Method 2

import java.lang.*;public class myCounter2 implements Runnable{                             public void run()                               {                               System.out.println(“I am a Thread”);


  • This is an Instance of the Thread class as a variable of the myCounter2 class – creates an interface
  • Can also extend the myCounter2 class
now create the thread1
Now create the thread

public class Do_it

{ public static void main (String args[]) {

Runnable worker = new myCounter2();

Thread thrd = new Thread (worker);


System.out.println(“I am the main thread”);



java threads 3
Java & Threads-3
  • Difference between the two methods
    • Implementing Runnable -> greater flexibility in the creation of the class counter
  • Thread class also implements the Runnable interface
java thread management
Java Thread Management
  • suspend() – suspends execution of the currently running thread.
  • sleep() – puts the currently running thread to sleep for a specified amount of time.
  • resume() – resumes execution of a suspended thread.
  • stop() – stops execution of a thread.