multi-threaded programming in java
DESCRIPTION
This presentation contains the topic Multi Threaded Programming in JAVA. Sources from all over internet.TRANSCRIPT
GUIDED BY:
DEVELOPED BY: Prof. Miral Patel
Multithreaded Programming in JAVA
Vikram Kalyani 120110116017
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
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.
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 dataIn a multithreaded system, a thread can be dedicated to listening
for data on the network portWhen data arrives, the thread reads it immediately and processes
it or delegates its processing to another thread
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.
Threads can be in one of four statesCreated, Running, Blocked, and Dead
A thread's state changes based on:Control methods such as start, sleep, yield, wait, notifyTermination of the run method
Thread States
Created Runnable Blocked
Dead
start()Thread()
run() method terminates
sleep()wait()
notify()
Java Threads
Java has built in thread support for Multithreading Synchronization Thread Scheduling Inter-Thread Communication: Java Garbage Collector is a low-priority thread
Threading Mechanisms
Create a class that extends the Thread class
Create a class that implements the Runnable interface
1st 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();
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
2nd 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();
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
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
Thread priority Exampleclass 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");
}
}
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");
}
}
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");
}
}
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.
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.
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()
Java Synchonization
Java provides Synchronized keyword to methods that cause only one invocation of a synchronized method on the same object at a time.
Examplepublic class SynchronizedCounter {
private int c = 0;
public synchronized void increment() {
c++;
}
public synchronized void decrement() {
c--;
}
public synchronized int value() {
return c;
}
}
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 Synchronized Statements
Example:
public void addName(String name) {synchronized(this) {
lastName = name;nameCount++;
} nameList.add(name);
}
Only this part synchronized
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
Coordinating threadsWait/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.
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.
THANK YOU!!!