Thread

You can define and instantiate a thread in one of two ways:

 Extend the java.lang.Thread class.

 Implement the Runnable interface.

Extending java.lang.Thread

The simplest way to define code to run in a separate thread is

to

 Extend the java.lang.Thread class.

 Override the run() method.

EX:-
class MyThread extends Thread {
public void run() {
System.out.println("Important job running in
MyThread");
}
}

Implementing java.lang.Runnable

Ex:-
class MyRunnable implements Runnable {
public void run() {
System.out.println("Important job running in
MyRunnable");
}
}
Thread States

A thread can be only in one of five states

 New This is the state the thread is in after the Thread

instance has been created, but the start() method has not
been invoked on the thread. It is a live Thread object, but
not yet a thread of execution.

 Runnable This is the state a thread is in when it's eligible

to run, but the scheduler has not selected it to be the
running thread. A thread first enters the runnable state
when the start() method is invoked, but a thread can also
return to the runnable state after either running or
coming back from a blocked, waiting, or sleeping state.
When the thread is in the runnable state, it is considered
alive.

 Running This is the state a thread is in when the thread

scheduler selects it to be the currently executing process.
one way to get to the running state: the scheduler chooses
a thread from the runnable pool.

 Dead A thread is considered dead when its run() method

completes. It may still be a viable Thread object, but it is
no longer a separate thread of execution. Once a thread is
dead, it can never be brought back to life. If you invoke
start()on a dead Thread instance, you'll get a runtime
exception.
Thread Priority

Thread.MIN_PRIORITY (1)
Thread.NORM_PRIORITY (5)
Thread.MAX_PRIORITY (10)

OR

threadobj.setPriority(int value);
threadobj.getPriority();

Thread Synchronization

When a thread is already action on an object, preventing any

other thread from acting on the same object is called Thread
synchronization or Thread Safe.

There two ways of doing so.

 Using Synchronize Block

Ex:-
synchronized (object) {

Statement ;
}

 Using synchronized keyword in method declaration.

Ex:-
synchronized void display() {

Ststement;
 }

sleep() Method

The sleep() method is a static method of class Thread.

You use it in your code to "slow a thread down" by forcing it
to go into a sleep mode before coming back to runnable .

You do this by invoking the static Thread.sleep() method,

giving it a time in milliseconds as follows:

try {
Thread.sleep(5*60*1000); // Sleep for 5 minutes
}catch (InterruptedException ex) { }

Notice that the sleep() method can throw a checked

InterruptedException

The yield( ) Method

The yield() method is supposed to do is make the currently

running thread head back to runnable to allow other threads
of the same priority to get their turn. So the intention is to use
yield() to promote graceful turn-taking among equal-priority
threads.

Thread.yield();// yield is static method of Thread class.

The join( ) Method

The non-static join() method of class Thread lets one thread

"join onto the end" of another thread. If you have a thread B
that can't do its work until another thread A has completed its
work, then you want thread B to "join" thread A. This means
that thread B will not become runnable until A has finished
(and entered the dead state).

 The methods wait() , notify(), and notifyAll() are methods

of
java.lang.Object.

 The methods static :-- sleep() and yield(), and which are
not static:--join() and start()are methods of
java.lang.Thread.

 The method run()is a method of java.lang.Runnable

Interface.