We can create a new thread using two ways:

1. Declare a class to be a subclass of Thread class.
2. Declare a class that implements the Runnable interface.

The code we want to execute has to be place in a method run() of the class which extends class Thread. This function will automatically call by using start().

The correct structure is: class MyClass extends Thread {       public void run()       {       } }

The correct state sequence for life cycle of a thread is:

1. New
2. Ready
3. Running
4. Blocked
5. Dead There is no return state.

When an allocated time of a thread is over, JRE puts it back in the ready state for giving the chance to another thread.

There is no thread priority constant as AVG_PRIORITY.

Here FirstTh must be a class which implements Runnable interface. Because the statements FirstTh th=new FirstTh(); Thread sm=new Thread(th).start(); Are used to create a thread by implementing Runnable interface.

The join() method of thread class makes the current thread to wait until other specified thread terminates.

All these methods must be called only when they own the monitor of that object, otherwise they throw IllegalMonitorStateException exception. These methods are used for proper coordination among the threads.

The package java.util gives two very useful classes, i.e. Timer and TimerTask. These classes are used for conjunction.

There are four constructors for a Timer class:

1. Timer()
2. Timer(Boolean isDaemon)
3. Timer(String name)
4. Timer(String name,Boolean isDaemon)

The purge() method of Timer class removes all cancelled tasks from this timer’s task queue.

A. The sleep() method is used to temporarily stop the execution of the thread. B. The join() method is used to wait for this thread to die.

Suppose a thread wants some input data. It cannot continue unless it is made available by the OS. Such a state is called a blocked state.

The destroy() method of thread class destroys this thread, without any clean-up.

Exception is a runtime error which terminates the program abruptly.

The package java.lang defines a class Throwable.

There are two sub-classes of a Throwable class:

1. Errors
2. Exceptions

Java has defined a RuntimeException class which is a super-class for all runtime error classes.

The code which is likely to produce an exception must be kept within the try block.

A block labelled as finally, just after the catch statements, will always be executed.

The throw statement is used to throw the object type exception.

The ArrayIndexOutOfBoundsException occurs if one is trying to access an element of array with an index that is larger than the range. For example: int Num[]={0,2,3}; Num[5]=0; /This statement throws the exception/

The exception ClassCastException is not a sub-class of RuntimeException.

An instance of ThreadDeath is thrown in the victim thread when the stop method is called with zero arguments in class Thread.

A finally block is optional. The keyword throw and throws are not the same. The keyword throws is used in method definition to represent that a method may possibly throw an exception.

The return type of start() method is void, i.e. void start().

In Java, the concept of synchronisation is based on the concept of intrinsic lock or monitor lock.