There are two types of executing the statements in MultiTasking.

Executing several task at a time by the microprocessor is called MultiTasking.

In MultiTasking the processor time is utilized in an optimum way

The 2 type of MultiTasking are as follows.

(i) Process Based MultiTasking :

In this several programs are executed by the Microprocessor using RoundRobin Method.

(ii) Thread Based MultiTasking :

Executing different parts (methods ) of the same program at a time using thread is called Thread Based MultiTasking.

Random Posts

• September 30, 2008 -- Explain Thread-Safe JSP page and there advantages (0)
• July 7, 2008 -- JSP Interview Questions (0)
• May 22, 2008 -- Core Java Interview Questions (1)
• September 22, 2008 -- Difference between #include and Import (2)
• August 15, 2008 -- Thread examples for extending (0)

Different states of a thread are :

–>New state, –>Runnable (Ready-to-run) state, –> Running state, –> Dead state, –> Blocked

Defining the different states of the theread is as follows::

1.  New state – After the creations of Thread instance the thread is in this state but before the start() method invocation. At this point, the thread is considered not alive.

2. Runnable (Ready-to-run) state – A thread start its life from Runnable state. A thread first enters runnable state after the invoking of start() method but a thread can return to this state after either running, waiting, sleeping or coming back from blocked state also. On this state a thread is waiting for a turn on the processor.

3. Running state – A thread is in running state that means the thread is currently executing. There are several ways to enter in Runnable state but there is only one way to enter in Running state: the scheduler select a thread from runnable pool.
4. Dead state – A thread can be considered dead when its run() method completes. If any thread comes on this state that means it cannot ever run again.
5. Blocked – A thread can enter in this state because of waiting the resources that are hold by another thread.

Random Posts

• September 2, 2008 -- Advantage of Cookies over URL (0)
• March 24, 2009 -- Define HashSet Class (0)
• July 30, 2010 -- Stored Procedures for Beginners (0)
• September 20, 2008 -- Difference between session.save() , session.saveOrUpdate() and session.persist() (0)
• September 2, 2008 -- Define HttpSession Class (0)

In particular,when we look at the life cycle of a thread: how to create and start a thread, some of the special things it can do while it’s running, and how to stop it.

The following shows the states that a Java thread can be in during its life. It also illustrates which method calls cause a transition to another state. This is an overview of the more interesting and common facets of a thread’s life. The remainder of this section uses the Clock applet introduced to discuss a thread’s life cycle in terms of its state.

Creating a Thread

The application in which an applet is running calls the applet’s start method when the user visits the applet’s page. The Clock applet creates a Thread, clockThread, in its start with the bold code shown here:

public void start() {
if (clockThread == null) {
clockThread = new Thread(this, “Clock”);
clockThread.start();
}
}

After the bold statement has been executed, clockThread is in the New Thread state. When a thread is a New Thread, it is merely an empty Thread object; no system resources have been allocated for it yet. When a thread is in this state, you can only start the thread. Calling any method besides start when a thread is in this state makes no sense and causes an IllegalThreadStateException. (In fact, the runtime system throws an IllegalThreadStateException any time a method is called on a thread and that thread’s state does not allow for that method call.)

Notice that this–the Clock instance– is the first argument to the thread constructor. The first argument to this thread constructor must implement the Runnable interface and becomes the thread’s target. The clock thread gets its run method from its target Runnable object–in this case, the Clock instance. The second argument is just a name for the thread.

Starting a Thread

Now consider the next line of code in Clock’s start method shown here in bold:

public void start() {
if (clockThread == null) {
clockThread = new Thread(this, “Clock”);
clockThread.start();
}
}

The start method creates the system resources necessary to run the thread, schedules the thread to run, and calls the thread’s run method. ClockThread’s run method is the one defined in the Clock class.

After the start method has returned, the thread is “running”. Yet, it’s somewhat more complex than that, a thread that has been started is actually in the Runnable state. Many computers have a single processor, thus making it impossible to run all “running” threads at the same time. The Java runtime system must implement a scheduling scheme that shares the processor between all “running” threads. (See Understanding Thread Priority for more information about scheduling.) So at any given time, a “running” thread actually may be waiting for its turn in the CPU.

Here’s another look at Clock’s run method:

public void run() {
Thread myThread = Thread.currentThread();
while (clockThread == myThread) {
repaint();
try {
Thread.sleep(1000);
} catch (InterruptedException e){
// the VM doesn’t want us to sleep anymore,
// so get back to work
}
}
}

Clock’s run method loops while the condition clockThread == myThread is true. This exit condition is explained in more detail in Stopping a Thread. However, for now, know that it allows the thread, and thus the applet, to exit gracefully.

Within the loop, the applet repaints itself and then tells the thread to sleep for one second (1000 milliseconds). An applet’s repaint method ultimately calls the applet’s paint method, which does the actual update of the applet’s display area. The Clock paint method gets the current time, formats, and displays it:

public void paint(Graphics g) {
// get the time and convert it to a date
Calendar cal = Calendar.getInstance();
Date date = cal.getTime();
// format it and display it
DateFormat dateFormatter = DateFormat.getTimeInstance();
g.drawString(dateFormatter.format(date), 5, 10);
}

Making a Thread Not Runnable

A thread becomes Not Runnable when one of these events occurs:

* Its sleep method is invoked.
* The thread calls the wait method to wait for a specific condition to be satisifed.
* The thread is blocking on I/O.

The clockThread in the Clock applet becomes Not Runnable when the run method calls sleep on the current thread:

public void run() {
Thread myThread = Thread.currentThread();
while (clockThread == myThread) {
repaint();
try {
Thread.sleep(1000);
} catch (InterruptedException e){
// the VM doesn’t want us to sleep anymore,
// so get back to work
}
}
}

During the second that the clockThread is asleep, the thread does not run, even if the processor becomes available. After the second has elapsed, the thread becomes Runnable again and, if the processor becomes available, the thread begins running again.

For each entrance into the Not Runnable state, there is a specific and distinct escape route that returns the thread to the Runnable state. An escape route works only for its corresponding entrance. For example, if a thread has been put to sleep, then the specified number of milliseconds must elapse before the thread becomes Runnable again. The following list describes the escape route for every entrance into the Not Runnable state:

* If a thread has been put to sleep, then the specified number of milliseconds must elapse.
* If a thread is waiting for a condition, then another object must notify the waiting thread of a change in condition by calling notify or notifyAll. More information is available in Synchronizing Threads.
* If a thread is blocked on I/O, then the I/O must complete.

Stopping a Thread

A program doesn’t stop a thread like it stops an applet (by calling a method). Rather, a thread arranges for its own death by having a run method that terminates naturally. For example, the while loop in this run method is a finite loop– it will iterate 100 times and then exit:

public void run() {
int i = 0;
while (i < 100) {
i++;
System.out.println(“i = ” + i);
}
}

A thread with this run method dies naturally when the loop completes and the run method exits.

Let’s look at how the Clock applet thread arranges for its own death. You might want to use this technique with your applets. Recall Clock’s run method:

public void run() {
Thread myThread = Thread.currentThread();
while (clockThread == myThread) {
repaint();
try {
Thread.sleep(1000);
} catch (InterruptedException e){
// the VM doesn’t want us to sleep anymore,
// so get back to work
}
}
}

The exit condition for this run method is the exit condition for the while loop because there is no code after the while loop:

while (clockThread == myThread) {

This condition indicates that the loop will exit when the currently exiting thread is not equal to clockThread. When would this ever be the case?

When you leave the page, the application in which the applet is running calls the applet’s stop method. This method then sets the clockThread to null, thereby telling the main loop in the run method to terminate:

public void stop() {    // applets’ stop method
clockThread = null;
}

If you revisit the page, the start method is called again and the clock starts up again with a new thread. Even if you stop and start the applet faster than one iteration of the loop, clockThread will be a different thread than myThread and the loop will still terminate.

The isAlive Method:

A final word about thread state: The API for the Thread class includes a method called isAlive. The isAlive method returns true if the thread has been started and not stopped. If the isAlive method returns false, you know that the thread either is a New Thread or is Dead. If the isAlive method returns true, you know that the thread is either Runnable or Not Runnable. You cannot differentiate between a New Thread or a Dead thread. Nor can you differentiate between a Runnable thread and a Not Runnable thread.

Random Posts

• December 16, 2008 -- Define Array in Java (1)
• July 7, 2008 -- Servlet Important Questions (0)
• April 4, 2009 -- Define Jar,War,Ear file (0)
• October 16, 2008 -- Servlet Summary (0)
• September 17, 2008 -- Hibernate Introduction (0)

public void run()

Inside run(),you will define the code that constitutes the new thread. It is important to understand that run() can call other methods, use other classes, and declare variables, just like the main thread can. The only difference is that run() establishes the entry point for another, concurrent thread of execution within your program. This thread will end when run() returns.

After you create a class that implements Runnable, you will instantiate an object of type Thread from within that class. Thread defines several constructors. The one that we will use is shown here:

Thread(Runnable threadOb, String threadName)

In the constructor, threadOb is an instance of a class that implements the Runnable interface. This defines where execution of the thread will begin. The name of the new thread is specified by threadName.

After the new thread is created, it will not start running until you call its start() method, which is declared within Thread. In essence, start() executres a call to run().

The start() method is shown here:

void start()

Here is an example that creates a new thread and starts it running:

Ex:#1;

//Create a second thread.

class NewThread implements Runnable{

Thread t;
NewThread(){

//Create a new, second thread
t=new Thread(this,”Demo Thread”);
System.out.println (“Child Thread:”+t);
t.start();  //Start the thread.
}

//This is the entry point for the second thread,

public void run() {
try{
for(int i=5;i>0;i–)  {
System.out.println(“Child Thread:”+i);
Thread.sleep(500);
}
}catch(InterruptedException e){
System.out.println(“Child interrupted.”);
}
System.out.println(“Exiting child thread.”);
}
}

class ThreadDemo {
public static void main(String args[]) {
new NewThread();  //create a new thread
try{
for(int i=5;i>0;i–)  {
System.out.println(“Main Thread:”+i)
Thread.sleep(1000);
}
}catch(InterruptedException e) {
System.out.println(“Main thread interrupted.”);
}
System.out.println(“Main thread exisiting.”);
}
}

Random Posts

• April 4, 2009 -- Java Interview Questions (0)
• July 15, 2008 -- Springs Interview Questions (7)
• August 10, 2008 -- Example programs of lifecycle of servlets (0)
• September 20, 2008 -- Difference between session.save() and session.saveOrUpdate() (0)
• April 5, 2009 -- How to get a Leap Year (0)

EX:

java.lang
Class InterruptedException

java.lang.Object
|___extended byjava.lang.Throwable
|___extended byjava.lang.Exception
|___extended byjava.lang.InterruptedException

All Implemented Interfaces:
Serializable

public class InterruptedException
extends Exception

Thrown when a thread is waiting, sleeping, or otherwise paused for a long time and another thread interrupts it using the interrupt method in class Thread.

Since:
JDK1.0
See Also:
Object.wait(), Object.wait(long), Object.wait(long, int), Thread.sleep(long), Thread.interrupt(), Thread.interrupted(), Serialized Form

Constructor Detail

–>InterruptedException

public InterruptedException()

Constructs an InterruptedException with no detail message.

–>InterruptedException

public InterruptedException(String s)

Constructs an InterruptedException with the specified detail message.

Parameters:
s – the detail message.

Related Post

• September 30, 2008 -- Define Precompile of Jsp page (0)
• September 22, 2008 -- Calling a Method in Java (1)
• September 2, 2008 -- Explain Session tracking using Servlet (0)
• August 24, 2008 -- Why does EJB needs two interfaces (0)
• August 24, 2008 -- Define NullPointerException (0)

Ex#1:

//create a second thread by extending Thread

class NewThread extends Thread{
NewThread() {
//create a new,second thread
super(“Demo Thread);
System.out.println(“child thread:”+this);
start();  //start the thread
}

//This is the entry point for the second thread.
public void run() {
try {
for(int i=5;i>0;i–) {
System.out.println(“Child thread:”+i);
Thread.sleep(500);
}catch (InterruptedException e) {
System.out.println(“child interrupted.”);
}
System.out.println(“Exiting child thread”);
}
}
class ExtendThread{
public static void main(String args[]){
new NewThread();  //create a new thread
try{
for(int i=5;i>0;i–)  {
System.out.println(“Main Thread:”+i);
Thread.sleep(1000);
}
}catch(InterruptedException e) {
System.out.println(“Main thread interrupted.”);
}
System.out.println(“main thread exiting”);
}
}

Random Posts

• September 22, 2008 -- What is Default Package in Java (0)
• July 21, 2010 -- How to Make a Class Serializable (1)
• August 24, 2008 -- What are synchronized methods and synchronized statements? (0)
• August 15, 2008 -- Life Cycle of Thread (0)
• June 8, 2008 -- Applet Interview Question (4)

Note: Every java program will have a thread.

The basic usage of the thread is as follows:

In the most general sense, you can create a thread by instantiating an object of type thread.
There are two ways to create a new thread.

–> You can Extend the Thread class in your class and override the method run().

Syntax :

public class MyThread extends Thread
{
public void run()
{
——
}
}

–> You can implement the Runnable interface and use that class in the Thread constructor

Syntax :

public class MyThread implements Runnale
{
public void run()
{
——
}
}

Random Posts

• September 2, 2008 -- Different types of Session Tracking (0)
• August 24, 2008 -- Difference between String and StringBuffer (0)
• December 17, 2008 -- What is Port Number (0)
• October 5, 2008 -- Thread safety of the servlet (0)
• September 2, 2008 -- Define Session Tracking (0)