java interview questions

Java Interview Questions 1 Java Interview Questions 2 Java Interview Questions 3 Java Interview Questions 4 Java Interview Questions 5                     

Question : What is Runnable interface ? Are there any other ways to make a java program as multithred java program?
Answer : There are two ways to create new kinds of threads:

- Define a new class that extends the Thread class
- Define a new class that implements the Runnable interface, and pass an object of that class to a Thread's constructor.
- An advantage of the second approach is that the new class can be a subclass of any class, not just of the Thread class.

    Here is a very simple example just to illustrate how to use the second approach to creating threads: 

   class myThread implements Runnable {
      public void run() {
	System.out.println("I'm running!");

public class tstRunnable {
    public static void main(String[] args) {
	myThread my1 = new myThread();
	myThread my2 = new myThread();
	new Thread(my1).start();
	new Thread(my2).start();

The Runnable interface has only one method:
public void run();
Thus, every class (thread) implements the Runnable interface, has to provide logic for run() method
Question : How can i tell what state a thread is in ?
Answer : Prior to Java 5, isAlive() was commonly used to test a threads state. If isAlive() returned false the thread was either new or terminated but there was simply no way to differentiate between the two.

Starting with the release of Tiger (Java 5) you can now get what state a thread is in by using the getState() method which returns an Enum of Thread.States. A thread can only be in one of the following states at a given point in time.

NEW A Fresh thread that has not yet started to execute.
RUNNABLE A thread that is executing in the Java virtual machine.
BLOCKED A thread that is blocked waiting for a monitor lock.
WAITING A thread that is wating to be notified by another thread.
TIMED_WAITING A thread that is wating to be notified by another thread for a specific amount of time
TERMINATED A thread whos run method has ended.
The folowing code prints out all thread states. 

public class ThreadStates{
 public static void main(String[] args){
  Thread t = new Thread();
  Thread.State e = t.getState(); 
  Thread.State[] ts = e.values(); 
  for(int i = 0; i < ts.length; i++){
Question : What methods java providing for Thread communications ?
Answer : Java provides three methods that threads can use to communicate with each other: wait, notify, and notifyAll. These methods are defined for all Objects (not just Threads). The idea is that a method called by a thread may need to wait for some condition to be satisfied by another thread; in that case, it can call the wait method, which causes its thread to wait until another thread calls notify or notifyAll.
Question : What is the difference between notify and notify All methods ?
Answer : A call to notify causes at most one thread waiting on the same object to be notified (i.e., the object that calls notify must be the same as the object that called wait). A call to notifyAll causes all threads waiting on the same object to be notified. If more than one thread is waiting on that object, there is no way to control which of them is notified by a call to notify (so it is often better to use notifyAll than notify).
Question : What is synchronized keyword? In what situations you will Use it?
Answer : Synchronization is the act of serializing access to critical sections of code. We will use this keyword when we expect multiple threads to access/modify the same data. To understand synchronization we need to look into thread execution manner.

Threads may execute in a manner where their paths of execution are completely independent of each other. Neither thread depends upon the other for assistance. For example, one thread might execute a print job, while a second thread repaints a window. And then there are threads that require synchronization, the act of serializing access to critical sections of code, at various moments during their executions. For example, say that two threads need to send data packets over a single network connection. Each thread must be able to send its entire data packet before the other thread starts sending its data packet; otherwise, the data is scrambled. This scenario requires each thread to synchronize its access to the code that does the actual data-packet sending.

If you feel a method is very critical for business that needs to be executed by only one thread at a time (to prevent data loss or corruption), then we need to use synchronized keyword.


Some real-world tasks are better modeled by a program that uses threads than by a normal, sequential program. For example, consider a bank whose accounts can be accessed and updated by any of a number of automatic teller machines (ATMs). Each ATM could be a separate thread, responding to deposit and withdrawal requests from different users simultaneously. Of course, it would be important to make sure that two users did not access the same account simultaneously. This is done in Java using synchronization, which can be applied to individual methods, or to sequences of statements.

One or more methods of a class can be declared to be synchronized. When a thread calls an object's synchronized method, the whole object is locked. This means that if another thread tries to call any synchronized method of the same object, the call will block until the lock is released (which happens when the original call finishes). In general, if the value of a field of an object can be changed, then all methods that read or write that field should be synchronized to prevent two threads from trying to write the field at the same time, and to prevent one thread from reading the field while another thread is in the process of writing it.

Here is an example of a BankAccount class that uses synchronized methods to ensure that deposits and withdrawals cannot be performed simultaneously, and to ensure that the account balance cannot be read while either a deposit or a withdrawal is in progress. (To keep the example simple, no check is done to ensure that a withdrawal does not lead to a negative balance.)

public class BankAccount {
    private double balance;

    // constructor: set balance to given amount
    public BankAccount( double initialDeposit ) {
        balance = initialDeposit;

    public synchronized double Balance( ) {
        return balance;

    public synchronized void Deposit( double deposit ) {
        balance += deposit;

    public synchronized void Withdraw( double withdrawal ) {
        balance -= withdrawal;

Note: that the BankAccount's constructor is not declared to be synchronized. That is because it can only be executed when the object is being created, and no other method can be called until that creation is finished.

There are cases where we need to synchronize a group of statements, we can do that using synchrozed statement.

Java Code Example

synchronized ( B ) {
    if ( D > B.Balance() ) {
    else {
        B.Withdraw( D );

Java Interview Questions 1 Java Interview Questions 2 Java Interview Questions 3 Java Interview Questions 4 Java Interview Questions 5