Multi-threaded Programming in JAVA

This presentation contains the topic Multi Threaded Programming in JAVA.

Sources from all over internet.

1. GUIDED BY: DEVELOPED BY : Prof. Miral Patel Multithreaded Programming in JAVA Vikram Kalyani 120110116017

2. What is Multithreading? A multi-processing Operating System can run several processes at the same time Each process has its own address/memory space The OS's scheduler decides when each process is executed Only one process is actually executing at any given time. However, the system appears to be running several programs simultaneously Separate processes to not have access to each other's memory space Many OSes have a shared memory system so that processes can share memory space In a multithreaded application, there are several points of execution within the same memory space. Each point of execution is called a thread Threads share access to memory

3. Why to use Multithreading? In a single threaded application, one thread of execution must do everything If an application has several tasks to perform, those tasks will be performed when the thread can get to them. A single task which requires a lot of processing can make the entire application appear to be "sluggish" or unresponsive. In a multithreaded application, each task can be performed by a separate thread If one thread is executing a long process, it does not make the entire application wait for it to finish. If a multithreaded application is being executed on a system that has multiple processors, the OS may execute separate threads simultaneously on separate processors.

4. What Kind of Applications Use Multithreading? Any kind of application which has distinct tasks which can be performed independently Any application with a GUI. Threads dedicated to the GUI can delegate the processing of user requests to other threads. The GUI remains responsive to the user even when the user's requests are being processed. Any application which requires asynchronous response Network based applications are ideally suited to multithreading. Data can arrive from the network at any time. In a single threaded system, data is queued until the thread can read the data In a multithreaded system, a thread can be dedicated to listening for data on the network port When data arrives, the thread reads it immediately and processes it or delegates its processing to another thread

5. 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.

6. Threads can be in one of four states Created, Running, Blocked, and Dead A thread's state changes based on: Control methods such as start, sleep, yield, wait, notify Termination of the run method Thread States Created Runnable Blocked Dead start() Thread() run() method terminates sleep() wait() notify()

7. Java Threads Java has built in thread support for Multithreading Synchronization Thread Scheduling Inter-Thread Communication: Java Garbage Collector is a low-priority thread

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

9. 1 st Method Extending Thread class Threads are implemented as objects that contains a method called run() class MyThread extends Thread { public void run() { // thread body of execution } } Create a thread: MyThread thr1 = new MyThread (); Start Execution of threads: thr1.start();

10. An example class MyThread extends Thread { // the thread public void run () { System.out.println (" this thread is running ... "); } } // end class MyThread class ThreadEx1 { // a program that utilizes the thread public static void main(String [] args ) { MyThread t = new MyThread (); // due to extending the Thread class (above) // I can call start(), and this will call // run(). start() is a method in class Thread. t.start (); } // end main() } // end class ThreadEx1

11. 2 nd Method Threads by implementing Runnable interface 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();

12. An example class MyThread implements Runnable { public void run() { System.out.println (" this thread is running ... "); } } // end class MyThread class ThreadEx2 { public static void main(String [] args ) { Thread t = new Thread(new MyThread ()); // due to implementing the Runnable interface // We can call start(), and this will call run(). t.start (); } // end main() } // end class ThreadEx2

13. 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 (ORM_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

14. 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"); } }

15. Thread priority Example(Cont.) 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"); } }

16. Thread priority Example(Cont.) 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"); } }

17. Deadlock: What is it ? A special type of error which occurs when two threads have a circular dependency on a pair of synchronized objects. For example, Traffic Jam. Device allocation Thread 1 requests tape drive 1 & gets it. Thread 2 requests tape drive 2 & gets it. Thread 1 requests tape drive 2 but is blocked. Thread 2 requests tape drive 1 but is blocked.

18. Deadlock as error: Deadlock is a difficult error to debug for two reasons.. In general, it occurs only rarely, when the two threads time-slice in just the right way. It may involve more than two threads and two synchronized objects.

19. Suspending, Resuming, and Stopping Threads Sometimes, suspending execution of a thread is useful as a solution of deadlock. The methods are…. void suspend( ) void resume( ) Void stop()

20. Java Synchonization Java provides Synchronized keyword to methods that cause only one invocation of a synchronized method on the same object at a time. Example public class SynchronizedCounter { private int c = 0; public synchronized void increment() { c++ ; } public synchronized void decrement() { c--; } public synchronized int value() { return c; } }

21. 21 Synchronized Statements Unlike synchronized methods, synchronized statements must specify the object that provides the intrinsic lock: Uses construct ion: synchronized ( expression ) { statements } Evaluate to an object or an array. Used to identify lock. “critical section”

22. 22 Synchronized Statements Example: public void addName (String name) { synchronized(this) { lastName = name; nameCount ++; } nameList.add (name); } Only this part synchronized

23. Atomic action An atomic action cannot stop in the middle: it either happens completely, or it doesn't happen at all. No side effects of an atomic action are visible until the action is complete. Read/writes can be declared atomic with the volatile keyword, e.g. private volatile int x; Sometimes can be more efficient than synchronized methods

24. Coordinating threads Wait/notify mechanism Sometimes need a thread to stop running and wait for an event before continuing. wait() and notify() methods are methods of class Object. Every object can maintain a list of waiting threads. wait(): When a thread calls wait() method of an object, any locks the thread holds are temporarily released and thread added to list of waiting threads for that object and stops running. notify(): When another thread calls notify() method on the same object, object wakes up one of the waiting threads and allows it to continue.

25. Join Sometimes one thread needs to stop and wait for another thread to complete . join() -- waits for a thread to die, i.e. thr1.join() waits for thread thr1 to die . Calling return() from the run method implicitly causes the thread to exit.

26. THANK YOU!!!