Multi-threaded Programming in JAVA

GUIDED BY:
Multithreaded Programming in JAVA
DEVELOPED BY: Prof. Miral Patel
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 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

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.

Thread States
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
notify()
Created Runnable Blocked
Dead
Thread() start()
run() method terminates
sleep()
wait()

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

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

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.

Multi-threaded Programming in JAVA

Multi-threaded Programming in JAVA

Recommended

More Related Content

What's hot (20)

Viewers also liked (20)

Similar to Multi-threaded Programming in JAVA (20)

More from Vikram Kalyani (6)

Recently uploaded (20)

Multi-threaded Programming in JAVA