Downloaded 175 times
![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](https://image.slidesharecdn.com/slideshare-140921040909-phpapp01/75/Multi-threaded-Programming-in-JAVA-10-2048.jpg)
![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](https://image.slidesharecdn.com/slideshare-140921040909-phpapp01/75/Multi-threaded-Programming-in-JAVA-12-2048.jpg)
![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"); } }](https://image.slidesharecdn.com/slideshare-140921040909-phpapp01/75/Multi-threaded-Programming-in-JAVA-16-2048.jpg)
Uploaded byVikram Kalyani
Multi-threaded Programming in JAVA
The document provides an overview of multithreading in Java, explaining its definition, benefits, and implementations. It covers fundamental concepts such as thread states, priority, synchronization, deadlock, and inter-thread communication mechanisms like wait/notify. The document also illustrates how to create threads and manage them effectively, emphasizing their importance in building responsive and efficient applications.
In this document
Powered by AI
Introduction by Prof. Miral Patel on multithreaded programming in Java, developed by Vikram Kalyani.
Definition of multithreading, explaining memory space, process execution, and how threads share memory.
Benefits of using multithreading, enabling tasks to run concurrently without blocking the application.
Examples of applications that benefit from multithreading, especially those with independent tasks or GUIs.
Description of threads in programming, how they enable concurrent execution in multithreaded programming.
Information on the states of threads (Created, Running, Blocked, Dead) and transitions between them.
Overview of Java's built-in support for threads, including synchronization and scheduling.
Methods for creating threads in Java: extending the Thread class and implementing the Runnable interface.
Code example demonstrating how to create and execute a thread by extending the Thread class.
Further example showing how to implement a thread by using the Runnable interface.
Discussion on thread priorities in Java, affecting scheduling and execution order of threads.
Examples illustrating how to set and manage thread priorities with multiple threads.
Definition of deadlock in threads when circular dependencies occur, illustrated with examples.
Challenges in debugging deadlocks due to their rare occurrence and complexity involving threads.
Methods for suspending, resuming, and stopping threads to manage deadlocks and execution flow.
Explanation of Java's synchronized keyword to control access to shared resources.
Details about using synchronized statements to manage critical sections in Java applications.
Definition of atomic actions that execute completely or not at all, enhancing efficiency.
Mechanisms for coordinating threads using wait and notify methods for managing execution flow.
Explanation of the join() method that allows threads to wait for completion of others.
Multi-threaded Programming in JAVA
- 1. GUIDED BY: MultithreadedProgramming in JAVA DEVELOPED BY: Prof. Miral Patel 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 useMultithreading? 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 ofApplications 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. Thread States Threadscan 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 notify() Created Runnable Blocked Dead Thread() start() run() method terminates sleep() wait()
- 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. 1st Method ExtendingThread 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 classMyThread 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. 2nd Method Threadsby 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 classMyThread 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 isit ? 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, andStopping 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 Anatomic 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/notifymechanism 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 Sometimesone 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.