Java

Interview Questions www.JavaInterview.in 1

MultiThreading
What is the need for Threads in Java?
Threads allow Java code to run in parallel. Lets look at an example to understand what we can do with
Threads.
Need for Threads
We are creating a Cricket Statistics Application. Let's say the steps involved in the application are

STEP I: Download and Store Bowling Statistics => 60 Minutes

STEP II: Download and Store Batting Statistics => 60 Minutes
STEP III: Download and Store Fielding Statistics => 15 Minutes
STEP IV: Merge and Analyze => 25 Minutes

Steps I, II and III are independent and can be run in parallel to each other. Run individually this program
takes 160 minutes. We would want to run this program in lesser time. Threads can be a solution to this
problem. Threads allow us to run STEP I, II and III in parallel and run Step IV when all Steps I, II and III are
completed.
Below example shows the way we would write code usually without using Threads.
ThreadExamples example = new ThreadExamples();
example.downloadAndStoreBattingStatistics();
example.downloadAndStoreBowlingStatistics();
example.downloadAndStoreFieldingStatistics();

example.mergeAndAnalyze();

downloadAndStoreBowlingStatistics starts only after downloadAndStoreBattingStatistics completes

execution. downloadAndStoreFieldingStatistics starts only after downloadAndStoreBowlingStatistics
completes execution. What if I want to run them in parallel without waiting for the others to complete?
This is where Threads come into picture. Using Multi-Threading we can run each of the above steps in
parallel and synchronize when needed. We will understand more about synchronization later.

How do you create a thread?

Creating a Thread class in Java can be done in two ways. Extending Thread class and implementing
Runnable interface. Lets create the BattingStatisticsThread extending Thread class and
BowlingStatisticsThread implementing Runnable interface.

How do you create a thread by extending Thread class?

Thread class can be created by extending Thread class and implementing the public void run() method.
Look at the example below: A dummy implementation for BattingStatistics is provided which counts
from 1 to 1000.

2 Java Interview Questions www.JavaInterview.in

class BattingStatisticsThread extends Thread {
//run method without parameters
public void run() {
for (int i = 0; i < 1000; i++)
System.out
.println("Running Batting Statistics Thread "
+ i);
}
}

How do you create a thread by implementing Runnable interface?

Thread class can also be created by implementing Runnable interface and implementing the method
declared in Runnable interface public void run(). Example below shows the Batting Statistics Thread
implemented by implementing Runnable interface.
class BowlingStatisticsThread implements Runnable {
//run method without parameters
public void run() {
for (int i = 0; i < 1000; i++)
System.out
.println("Running Bowling Statistics Thread "
+ i);
}
}

How do you run a Thread in Java?

Running a Thread in Java is slightly different based on the approach used to create the thread.
Thread created Extending Thread class
When using inheritance, An object of the thread needs be created and start() method on the thread
needs to be called. Remember that the method that needs to be called is not run() but it is start().
BattingStatisticsThread battingThread1 = new BattingStatisticsThread();
battingThread1.start();

Thread created implementing RunnableInterface.

Three steps involved.

Create an object of the BowlingStatisticsThread(class implementing Runnable).

Create a Thread object with the earlier object as constructor argument.
Call the start method on the thread.

BowlingStatisticsThread battingInterfaceImpl = new BowlingStatisticsThread();

Thread battingThread2 = new Thread(
battingInterfaceImpl);
battingThread2.start();

What are the different states of a Thread?

Different states that a thread can be in are defined the class State.

Java Interview Questions www.JavaInterview.in 3

NEW;
RUNNABLE;
RUNNING;
BLOCKED/WAITING;
TERMINATED/DEAD;

Lets consider the example that we discussed earlier.

Example Program
LINE 1: BattingStatisticsThread battingThread1 = new BattingStatisticsThread();
LINE 2: battingThread1.start();

LINE 3: BowlingStatisticsThread battingInterfaceImpl = new BowlingStatisticsThread();
LINE 4: Thread battingThread2 = new Thread(battingInterfaceImpl);
LINE 5:battingThread2.start();

Description
A thread is in NEW state when an object of the thread is created but the start method is not yet called.
At the end of line 1, battingThread1 is in NEW state.
A thread is in RUNNABLE state when it is eligible to run, but not running yet. (A number of Threads can
be in RUNNABLE state. Scheduler selects which Thread to move to RUNNING state). In the above
example, sometimes the Batting Statistics thread is running and at other time, the Bowling Statistics
Thread is running. When Batting Statistics thread is Running, the Bowling Statistics thread is ready to
run. Its just that the scheduler picked Batting Statistics thread to run at that instance and vice-versa.
When Batting Statistics thread is Running, the Bowling Statistics Thread is in Runnable state (Note that
the Bowling Statistics Thread is not waiting for anything except for the Scheduler to pick it up and run it).
A thread is RUNNING state when its the one that is currently , what else to say, Running.
A thread is in BLOCKED/WAITING/SLEEPING state when it is not eligible to be run by the Scheduler.
Thread is alive but is waiting for something. An example can be a Synchronized block. If Thread1 enters
synchronized block, it blocks all the other threads from entering synchronized code on the same
instance or class. All other threads are said to be in Blocked state.
A thread is in DEAD/TERMINATED state when it has completed its execution. Once a thread enters dead
state, it cannot be made active again.

What is priority of a thread? How do you change the priority of a thread?

Scheduler can be requested to allot more CPU to a thread by increasing the threads priority. Each thread
in Java is assigned a default Priority 5. This priority can be increased or decreased (Range 1 to 10).
If two threads are waiting, the scheduler picks the thread with highest priority to be run. If all threads
have equal priority, the scheduler then picks one of them randomly. Design programs so that they don't
depend on priority.

4 Java Interview Questions www.JavaInterview.in

Thread Priority Example
Consider the thread example declared below:
class ThreadExample extends Thread {
public void run() {
for (int i = 0; i < 1000; i++)
System.out
.println( this.getName() + " Running "
+ i);
}
}

Priority of thread can be changed by invoking setPriority method on the thread.

ThreadExample thread1 = new ThreadExample();
thread1.setPriority(8);

Java also provides predefined constants Thread.MAX_PRIORITY(10), Thread.MIN_PRIORITY(1),

Thread.NORM_PRIORITY(5) which can be used to assign priority to a thread.

Java Interview Questions www.JavaInterview.in

At http://www.JavaInterview.in, we want you to clear java interview with ease. So, in addition to
focussing on Core and Advanced Java we also focus on topics like Code Reviews, Performance, Design
Patterns, Spring and Struts.
We have created more than 20 videos to help you understand these topics and become an expert at
them. Visit our website http://www.JavaInterview.in for complete list of videos. Other than the videos,
we answer the top 200 frequently asked interview questions on our website.
With more 900K video views (Apr 2015), we are the most popular channel on Java Interview Questions
on YouTube.
Register here for more updates : https://feedburner.google.com/fb/a/mailverify?uri=RithusTutorials
Java Interview : A Freshers Guide - Part 1: https://www.youtube.com/watch?v=njZ48YVkei0
Java Interview : A Freshers Guide - Part 2: https://www.youtube.com/watch?v=xyXuo0y-xoU
Java Interview : A Guide for Experienced: https://www.youtube.com/watch?v=0xcgzUdTO5M
Collections Interview Questions 1: https://www.youtube.com/watch?v=GnR4hCvEIJQ
Collections Interview Questions 2: https://www.youtube.com/watch?v=6dKGpOKAQqs
Collections Interview Questions 3: https://www.youtube.com/watch?v=_JTIYhnLemA
Collections Interview Questions 4: https://www.youtube.com/watch?v=ZNhT_Z8_q9s
Collections Interview Questions 5: https://www.youtube.com/watch?v=W5c8uXi4qTw

Java Interview Questions www.JavaInterview.in 5

Synchronization
What is synchronization of threads?
Since Threads run in parallel, a new problem arises. What if thread1 modifies data which is being
accessed by thread2? How do we ensure that different threads dont leave the system in an inconsistent
state? This problem is usually called synchronization problem.
Lets first look at an example where this problem can occur. Consider the code in the setAndGetSum
method.
int setandGetSum(int a1, int a2, int a3) {
cell1 = a1;
sleepForSomeTime();
cell2 = a2;
sleepForSomeTime();
cell3 = a3;
sleepForSomeTime();
return cell1 + cell2 + cell3;
}

If following method is running in two different threads, funny things can happen. After setting the value
to each cell, there is a call for the Thread to sleep for some time. After Thread 1 sets the value of cell1, it
goes to Sleep. So, Thread2 starts executing. If Thread 2 is executing return cell1 + cell2 + cell3;, it uses
cell1 value set by Thread 1 and cell2 and cell3 values set by Thread 2. This results in the unexpected
results that we see when the method is run in parallel. What is explained is one possible scenario. There
are several such scenarios possible.
The way you can prevent multiple threads from executing the same method is by using the synchronized
keyword on the method. If a method is marked synchronized, a different thread gets access to the
method only when there is no other thread currently executing the method.
Lets mark the method as synchronized:
synchronized int setandGetSum(int a1, int a2, int a3) {
cell1 = a1;
sleepForSomeTime();
cell2 = a2;
sleepForSomeTime();
cell3 = a3;
sleepForSomeTime();
return cell1 + cell2 + cell3;
}

Can you give an example of a synchronized block?

All code which goes into the block is synchronized on the current object.
void synchronizedExample2() {
synchronized (this){
//All code goes here..

6 Java Interview Questions www.JavaInterview.in

}
}

Can a static method be synchronized?

Yes. Consider the example below.
synchronized static int getCount(){
return count;
}

Static methods and block are synchronized on the class. Instance methods and blocks are synchronized
on the instance of the class i.e. an object of the class. Static synchronized methods and instance
synchronized methods dont affect each other. This is because they are synchronized on two different
things.
static int getCount2(){
synchronized (SynchronizedSyntaxExample.class) {
return count;
}
}

What is the use of join method in threads?

Join method is an instance method on the Thread class. Let's see a small example to understand what
join method does.
Lets consider the thread's declared below: thread2, thread3, thread4
ThreadExample thread2 = new ThreadExample();
ThreadExample thread3 = new ThreadExample();
ThreadExample thread4 = new ThreadExample();

Lets say we would want to run thread2 and thread3 in parallel but thread4 can only run when thread3
is finished. This can be achieved using join method.
Join method example
Look at the example code below:
thread3.start();
thread2.start();
thread3.join();//wait for thread 3 to complete
System.out.println("Thread3 is completed.");
thread4.start();

thread3.join() method call force the execution of main method to stop until thread3 completes
execution. After that, thread4.start() method is invoked, putting thread4 into a Runnable State.
Overloaded Join method
Join method also has an overloaded method accepting time in milliseconds as a parameter.
thread4.join(2000);

Java Interview Questions www.JavaInterview.in 7

In above example, main method thread would wait for 2000 ms or the end of execution of thread4,
whichever is minimum.

Describe a few other important methods in Threads?

Thread yield method
Yield is a static method in the Thread class. It is like a thread saying " I have enough time in the limelight.
Can some other thread run next?".
A call to yield method changes the state of thread from RUNNING to RUNNABLE. However, the
scheduler might pick up the same thread to run again, especially if it is the thread with highest priority.
Summary is yield method is a request from a thread to go to Runnable state. However, the scheduler
can immediately put the thread back to RUNNING state.
Thread sleep method
sleep is a static method in Thread class. sleep method can throw a InterruptedException. sleep method
causes the thread in execution to go to sleep for specified number of milliseconds.

What is a deadlock?
Lets consider a situation where thread1 is waiting for thread2 ( thread1 needs an object whose
synchronized code is being executed by thread1) and thread2 is waiting for thread1. This situation is
called a Deadlock. In a Deadlock situation, both these threads would wait for one another for ever.

What are the important methods in java for inter-thread communication?

Important methods are wait, notify and notifyAll.

What is the use of wait method?

Below snippet shows how wait is used. wait method is defined in the Object class. This causes the
thread to wait until it is notified.
synchronized(thread){
thread.start();
thread.wait();
}

What is the use of notify method?

Below snippet shows how notify is used. notify method is defined in the Object class. This causes the
object to notify other waiting threads.
synchronized (this) {
calculateSumUptoMillion();
notify();
}

What is the use of notifyAll method?

If more than one thread is waiting for an object, we can notify all the threads by using notifyAll method.

8 Java Interview Questions www.JavaInterview.in

thread.notifyAll();

Can you write a synchronized program with wait and notify methods?
package com.rithus.threads;

class Calculator extends Thread {
long sumUptoMillion;
long sumUptoTenMillion;

public void run() {
synchronized (this) {
calculateSumUptoMillion();
notify();
}
calculateSumUptoTenMillion();
}

private void calculateSumUptoMillion() {
for (int i = 0; i < 1000000; i++) {
sumUptoMillion += i;
}
System.out.println("Million done");
}

private void calculateSumUptoTenMillion() {
for (int i = 0; i < 10000000; i++) {
sumUptoTenMillion += i;
}
System.out.println("Ten Million done");
}
}

public class ThreadWaitAndNotify {
public static void main(String[] args) throws InterruptedException {
Calculator thread = new Calculator();
synchronized(thread){
thread.start();
thread.wait();
}
System.out.println(thread.sumUptoMillion);
}
}

Output
Million done
499999500000
Ten Million done