Threads by LBY2ks

VIEWS: 17 PAGES: 46

									  Multithreaded Programming
      using Java Threads



                  Prof. Rajkumar Buyya
 Cloud Computing and Distributed Systems (CLOUDS) Laboratory
  Dept. of Computer Science and Software Engineering
            University of Melbourne, Australia
http://www.cloudbus.org/~raj or http://www.buyya.com

                                                               1
                          Agenda
   Introduction
   Thread Applications
   Defining Threads
   Java Threads and States
       Priorities
   Accessing Shared Resources
       Synchronisation
   Assignment 1:
       Multi-Threaded Math Server
   Advanced Issues:
       Concurrency Models: master/worker, pipeline, peer processing
       Multithreading Vs multiprocessing


                                                                       2
    A single threaded program

class ABC
{
….
    public void main(..)    begin

    {
    …                      body

    ..
                           end
    }
}

                                    3
A Multithreaded Program

                      Main Thread




                                       start
           start       start




Thread A             Thread B                  Thread C




 Threads may switch or exchange data/results
                                                          4
     Single and Multithreaded
             Processes
       threads are light-weight processes within a process

Single-threaded Process                  Multiplethreaded Process
                            Threads of
                            Execution




Single instruction stream                Multiple instruction stream
                            Common
                            Address Space

                                                                  5
Multithreaded Server: For Serving
  Multiple Clients Concurrently


 Client 1 Process                  Server Process

                                       Server
                                      Threads
                       Internet


 Client 2 Process




                                                    6
    Web/Internet Applications:
Serving Many Users Simultaneously

                                     PC client


        Internet
        Server
                   Local Area Network




                                PD
                                A
                                                 7
  Modern Applications need Threads (ex1):
Editing and Printing documents in background.
                              Printing Thread



 Editing Thread




                                                8
Multithreaded/Parallel File Copy

  reader()
  {                                    writer()
      - - - - - - - - -    buff[0]     {
      -                                    - - - - - - - - - -
      lock(buff[i]);                       lock(buff[i]);
      read(src,buff[i]);   buff[1]
                                           write(src,buff[i]);
      unlock(buff[i]);                     unlock(buff[i]);
      - - - - - - - - -                    - - - - - - - - - -
      -                                }
  }




            Cooperative Parallel Synchronized
                        Threads
                                                                 9
            Levels of Parallelism
                                                        Code-Granularity
                                                        Code Item
Sockets/    Task i-l        Task i         Task i+1     Large grain
PVM/MPI                                                 (task level)
                                                        Program

               func1 ( )     func2 ( )      func3 ( )
               {             {              {           Medium grain
               ....          ....
Threads        ....          ....
                                            ....
                                            ....
                                                        (control level)
               }             }              }
                                                        Function (thread)


                                                        Fine grain
              a ( 0 ) =..   a ( 1 )=..    a ( 2 )=..    (data level)
Compilers     b ( 0 ) =..   b ( 1 )=..    b ( 2 )=..
                                                        Loop (Compiler)

                                                        Very fine grain
CPU                   +         x        Load           (multiple issue)
                                                        With hardware
                                                                           10
         What are Threads?

   A piece of code that run in concurrent with
    other threads.
   Each thread is a statically ordered sequence of
    instructions.
   Threads are being extensively used express
    concurrency on both single and
    multiprocessors machines.
   Programming a task having multiple threads of
    control – Multithreading or Multithreaded
    Programming.
                                                  11
                Java Threads

   Java has built in thread support for
    Multithreading
   Synchronization
   Thread Scheduling
   Inter-Thread Communication:
       currentThread    start       setPriority
       yield            run         getPriority
       sleep            stop        suspend
       resume
   Java Garbage Collector is a low-priority thread.

                                                   12
           Threading Mechanisms...
   Create a class that extends the Thread class
   Create a class that implements the Runnable
    interface

       Thread                  Runnable             Thread



      MyThread                   MyClass




(objects are threads)   (objects with run() body)

         [a]                          [b]

                                                             13
         1st method: Extending Thread
                     class
   Create a class by extending Thread class and override
    run() method:
     class MyThread extends Thread
     {
          public void run()
        {
            // thread body of execution
        }
     }
   Create a thread:
     MyThread thr1 = new MyThread();
   Start Execution of threads:
     thr1.start();
   Create and Execute:
     new MyThread().start();



                                                        14
                    An example
class MyThread extends Thread {
      public void run() {
            System.out.println(" this thread is running ... ");
      }
}

class ThreadEx1 {
      public static void main(String [] args ) {
        MyThread t = new MyThread();
         t.start();
     }
}




                                                                  15
          2nd method: Threads by
      implementing Runnable interface
   Create a class that implements the interface Runnable and
    override run() method:
class MyThread implements Runnable
{
  .....
  public void run()
  {
      // thread body of execution
  }
}
 Creating Object:
    MyThread myObject = new MyThread();
 Creating Thread Object:
    Thread thr1 = new Thread( myObject );
 Start Execution:
    thr1.start();




                                                                16
                   An example
class MyThread implements Runnable {
      public void run() {
            System.out.println(" this thread is running ... ");
      }
}

class ThreadEx2 {
      public static void main(String [] args ) {
            Thread t = new Thread(new MyThread());
             t.start();
      }
}




                                                                  17
    Life Cycle of Thread
  new
           start()
                                                       I/O completed

                       ready
                                Time expired/   resume()
notify()                         interrupted

                                  sleeping        blocked
waiting
                dispatch
                           sleep()
   wait()                                   suspend()
                     running                     Block on I/O
                               completion

                               stop()           dead
                                                                       18
A Program with Three Java Threads

    Write a program that creates 3 threads




                                              19
         Three threads example
   class A extends Thread
   {
       public void run()
         {
            for(int i=1;i<=5;i++)
             {
                 System.out.println("\t From ThreadA: i= "+i);
             }
              System.out.println("Exit from A");
         }
   }

   class B extends Thread
   {
       public void run()
         {
            for(int j=1;j<=5;j++)
             {
                 System.out.println("\t From ThreadB: j= "+j);
             }
              System.out.println("Exit from B");
         }
   }




                                                                  20
   class C extends Thread
   {
       public void run()
         {
            for(int k=1;k<=5;k++)
             {
                 System.out.println("\t From ThreadC: k= "+k);
             }

             System.out.println("Exit from C");
        }
   }

   class ThreadTest
   {
         public static void main(String args[])
          {
               new A().start();
               new B().start();
               new C().start();
          }
   }




                                                                  21
                                  Run 1
    [raj@mundroo] threads [1:76] java ThreadTest
       From ThreadA: i= 1
       From ThreadA: i= 2
       From ThreadA: i= 3
       From ThreadA: i= 4
       From ThreadA: i= 5
Exit from A
       From ThreadC: k= 1
       From ThreadC: k= 2
       From ThreadC: k= 3
       From ThreadC: k= 4
       From ThreadC: k= 5
Exit from C
       From ThreadB: j= 1
       From ThreadB: j= 2
       From ThreadB: j= 3
       From ThreadB: j= 4
       From ThreadB: j= 5
Exit from B




                                                    22
                                   Run2
    [raj@mundroo] threads [1:77] java ThreadTest
       From ThreadA: i= 1
       From ThreadA: i= 2
       From ThreadA: i= 3
       From ThreadA: i= 4
       From ThreadA: i= 5
       From ThreadC: k= 1
       From ThreadC: k= 2
       From ThreadC: k= 3
       From ThreadC: k= 4
       From ThreadC: k= 5
Exit from C
       From ThreadB: j= 1
       From ThreadB: j= 2
       From ThreadB: j= 3
       From ThreadB: j= 4
       From ThreadB: j= 5
Exit from B
Exit from A




                                                    23
                   Process Parallelism
         int add (int a, int b, int & result)
         // function stuff
         int sub(int a, int b, int & result)             Data
         // function stuff                   Processor
                                       IS1                 a
                                               add
pthread t1, t2;
                                                           b
pthread-create(&t1, add, a,b, & r1);                       r1
                                             Processor
pthread-create(&t2, sub, c,d, & r2);                        c
pthread-par (2, t1, t2);               IS2
                                               sub         d
                                                           r2
          MISD and MIMD Processing
                                                                 24
                           Data Parallelism
           sort( int *array, int count)                        Data
           //......
                                                    Processor
           //......                                             do
                                                      Sort
                                                                  “
pthread-t, thread1, thread2;                                      “
“                                              IS
“                                                                dn/2
pthread-create(& thread1, sort, array, N/2);
pthread-create(& thread2, sort, array, N/2);        Processor
pthread-par(2, thread1, thread2);
                                                                dn2/+1
                                                      Sort        “
                                                                  “
                                                                 dn
                    SIMD Processing
                                                                         25
                   Thread Priority

   In Java, each thread is assigned priority, which
    affects the order in which it is scheduled for
    running. The threads so far had same default
    priority (NORM_PRIORITY) and they are served
    using FCFS policy.
       Java allows users to change priority:
            ThreadName.setPriority(intNumber)
                 MIN_PRIORITY = 1
                 NORM_PRIORITY=5
                 MAX_PRIORITY=10



                                                   26
         Thread Priority Example
class A extends Thread
{
    public void run()
     {
         System.out.println("Thread A started");
         for(int i=1;i<=4;i++)
           {
               System.out.println("\t From ThreadA: i= "+i);
           }
            System.out.println("Exit from A");
     }
}
class B extends Thread
{
     public void run()
       {
          System.out.println("Thread B started");
          for(int j=1;j<=4;j++)
            {
                System.out.println("\t From ThreadB: j= "+j);
            }
             System.out.println("Exit from B");
       }
}



                                                                27
           Thread Priority Example
class C extends Thread
{
     public void run()
       {
           System.out.println("Thread C started");
           for(int k=1;k<=4;k++)
             {
                  System.out.println("\t From ThreadC: k= "+k);
             }
              System.out.println("Exit from C");
       }
}
class ThreadPriority
{
        public static void main(String args[])
         {
                  A threadA=new A();
                  B threadB=new B();
                  C threadC=new C();
                threadC.setPriority(Thread.MAX_PRIORITY);
                threadB.setPriority(threadA.getPriority()+1);
                threadA.setPriority(Thread.MIN_PRIORITY);
                System.out.println("Started Thread A");
                 threadA.start();
                System.out.println("Started Thread B");
                 threadB.start();
                System.out.println("Started Thread C");
                 threadC.start();
                 System.out.println("End of main thread");
         }
}

                                                                  28
Accessing Shared Resources

   Applications Access to Shared Resources need
    to be coordinated.
       Printer (two person jobs cannot be printed at the
        same time)
       Simultaneous operations on your bank account.
       Can the following operations be done at the same
        time on the same account?
            Deposit()
            Withdraw()
            Enquire()



                                                            29
Online Bank: Serving Many Customers
           and Operations

                                            PC client


         Internet Bank
         Server
                          Local Area Network




                 Bank
               Database                PD
                                       A
                                                        30
                    Shared Resources

   If one thread tries to read the data and other
    thread tries to update the same data, it leads to
    inconsistent state.
   This can be prevented by synchronising access
    to the data.
   Use “Synchronized” method:
       public synchronized void update()
       {
               …
       }


                                                   31
    the driver: 3rd Threads sharing
            the same object
class InternetBankingSystem {
     public static void main(String [] args ) {
        Account accountObject = new Account ();
       Thread t1 = new Thread(new MyThread(accountObject));
       Thread t2 = new Thread(new YourThread(accountObject));
       Thread t3 = new Thread(new HerThread(accountObject));
        t1.start();
        t2.start();
        t3.start();
      // DO some other operation
    } // end main()
}

                                                                32
             Shared account object
               between 3 threads
class MyThread implements Runnable {
 Account account;
      public MyThread (Account s) { account = s;}
      public void run() { account.deposit(); }
} // end class MyThread

class YourThread implements Runnable {                account
 Account account;
      public YourThread (Account s) { account = s;}
                                                      (shared
      public void run() { account.withdraw(); }       object)
} // end class YourThread

class HerThread implements Runnable {
 Account account;
      public HerThread (Account s) { account = s; }
      public void run() {account.enquire(); }
} // end class HerThread
                                                            33
  Monitor (shared object access):
serializes operation on shared object
  class Account { // the 'monitor'
    int balance;

      // if 'synchronized' is removed, the outcome is unpredictable
       public synchronized void deposit( ) {
          // METHOD BODY : balance += deposit_amount;
        }

        public synchronized void withdraw( ) {
          // METHOD BODY: balance -= deposit_amount;
        }
        public synchronized void enquire( ) {
          // METHOD BODY: display balance.
        }
  }


                                                                      34
        Multithreaded Server   Multithreaded Server


                               Server Process
         Client Process
                                     Server
                                    Threads

Client Process


                                               User Mode

                                              Kernel Mode
                  Message Passing
                     Facility



                                                            35
 Assignment 1: Multithreaded MathServer –
Demonstrates the use of Sockets and Threads



  A Client Program       “sqrt 4.0”
  What is sqrt(10)?                      Multithreaded
                                           MathServer
                              “2.0”
                                      (sin, cos, sqrt, etc.)
  A Client Program
  What is sin(10)?




              A Client
           Program in “C”                      A Client
           What is sin(10)?                Program in “C++”
                                            What is sin(10)?

                                                               36
A Multithreaded Program
                  MathThreads


          start     start       start




MathSin           MathCos               MathTan




           join      join        join



                  MathThreads

                                                  37
         Thread Programming models
Thread concurrency/operation models

     The master/worker model
     The peer model
     A thread pipeline




                                 38
     The master/worker model

                 Program                      Resources
                            Workers
                             taskX
                                      Files

                 Master                       Databases
                             taskY
                 main ( )
Input (Stream)

                                      Disks
                             taskZ

                                                      Special
                                                      Devices




                                                                39
        The peer model

        Program                     Resources
                  Workers
Input              taskX
                            Files

                                    Databases
                   taskY



                            Disks
                   taskZ

                                            Special
                                            Devices




                                                      40
                            A thread
                 A thread pipeline pipeline

    Program      Filter Threads
                  Stage 1           Stage 2           Stage 3

Input (Stream)




    Resources           Files             Files                 Files

                        Databases         Databases             Databases


                            Disks             Disks                Disks



                 Special Devices    Special Devices    Special Devices



                                                                            41
     Multithreading and
Multiprocessing Deployment
            issues
 On Shared and distributed
     memory systems



                             42
Multithreading - Multiprocessors

   Process Parallelism

                                                      CPU
     P1

     P2                                               CPU

     P3                                               CPU




                         time

    No of execution processes <= the number of CPUs

                                                            43
Multithreading on Uni-processor

    Concurrency Vs Parallelism
      Process Concurrency

       P1

       P2                                           CPU

       P3



                             time


 Number of Simultaneous execution units > number of CPUs
                                                           44
  Multi-Processing (clusters & grids)
   and Multi-Threaded Computing
        Threaded Libraries, Multi-threaded I/O

                              Application

         Application                                  Application

Application
                                         CPU
                             CPU
                     CPU                       CPU        CPU        CPU

              Better Response Times in         Higher Throughput for
              Multiple Application             Parallelizeable Applications
              Environments
                                                                         45
                 References

   Rajkumar Buyya, Thamarai Selvi,
    Xingchen Chu, Mastering OOP with
    Java, McGraw Hill (I) Press, New Delhi,
    India, 2009.
   Sun Java Tutorial – Concurrency:
       http://java.sun.com/docs/books/tutorial/esse
        ntial/concurrency/



                                                   46

								
To top