Multi-threaded Programming in JAVA

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