File Doc Category Size Date Package
Thread.java API Doc phoneME MR2 API (J2ME) 9591 Wed May 02 17:59:54 BST 2007 java.lang

Thread

java.lang.Object

public class Thread extends Object implements Runnable

A thread is a thread of execution in a program. The Java Virtual Machine allows an application to have multiple threads of execution running concurrently.

Every thread has a priority. Threads with higher priority are executed in preference to threads with lower priority.

There are two ways to create a new thread of execution. One is to declare a class to be a subclass of Thread. This subclass should override the run method of class Thread. An instance of the subclass can then be allocated and started. For example, a thread that computes primes larger than a stated value could be written as follows:

class PrimeThread extends Thread {
long minPrime;
PrimeThread(long minPrime) {
this.minPrime = minPrime;
}

public void run() {
// compute primes larger than minPrime
 . . .
}
}

The following code would then create a thread and start it running:

PrimeThread p = new PrimeThread(143);
p.start();

The other way to create a thread is to declare a class that implements the Runnable interface. That class then implements the run method. An instance of the class can then be allocated, passed as an argument when creating Thread, and started. The same example in this other style looks like the following:

class PrimeRun implements Runnable {
long minPrime;
PrimeRun(long minPrime) {
this.minPrime = minPrime;
}

public void run() {
// compute primes larger than minPrime
 . . .
}
}

The following code would then create a thread and start it running:

PrimeRun p = new PrimeRun(143);
new Thread(p).start();

version: 1.105, 12/04/99 (CLDC 1.0, Spring 2000)
see: java.lang.Runnable
see: java.lang.Runtime#exit(int)
see: java.lang.Thread#run()
since: JDK1.0

Fields Summary
private int
priority
private Runnable
target
private Object
vm_thread
private int
is_terminated
private int
is_stillborn
public static final int
MIN_PRIORITY
The minimum priority that a thread can have.
public static final int
NORM_PRIORITY
The default priority that is assigned to a thread.
public static final int
MAX_PRIORITY
The maximum priority that a thread can have.
Constructors Summary
public Thread()
Allocates a new Thread object.
Threads created this way must have overridden their run() method to actually do anything.
see
java.lang.Runnable
/* The VM initializes the thread "under the hood" */ // this(null);
public Thread(Runnable target)
Allocates a new Thread object with a specific target object whose run method is called.
param
target the object whose run method is called.
Thread parent = currentThread(); this.priority = parent.getPriority(); this.target = target; setPriority(priority);
Methods Summary
public static native int activeCount()
Returns the current number of active threads in the VM.
return
the current number of active threads.
public static native java.lang.Thread currentThread()
Returns a reference to the currently executing thread object.
return
the currently executing thread.
public final int getPriority()
Returns this thread's priority.
return
this thread's priority.
see
#setPriority
see
java.lang.Thread#setPriority(int)
return priority;
private native synchronized void internalExit()
public final native boolean isAlive()
Tests if this thread is alive. A thread is alive if it has been started and has not yet died.
return
true if this thread is alive; false otherwise.
public final synchronized void join()
Waits for this thread to die.
exception
InterruptedException if another thread has interrupted the current thread. The interrupted status of the current thread is cleared when this exception is thrown.
while (isAlive()) { wait(1000); }
public void run()
If this thread was constructed using a separate Runnable run object, then that Runnable object's run method is called; otherwise, this method does nothing and returns.
Subclasses of Thread should override this method.
see
java.lang.Thread#start()
see
java.lang.Runnable#run()
if (target != null) { target.run(); }
public final void setPriority(int newPriority)
Changes the priority of this thread.
param
newPriority priority to set this thread to
exception
IllegalArgumentException If the priority is not in the range MIN_PRIORITY to MAX_PRIORITY.
see
#getPriority
see
java.lang.Thread#getPriority()
see
java.lang.Thread#MAX_PRIORITY
see
java.lang.Thread#MIN_PRIORITY
if (newPriority > MAX_PRIORITY || newPriority < MIN_PRIORITY) { throw new IllegalArgumentException(); } setPriority0(priority, newPriority); priority = newPriority;
private native void setPriority0(int oldPriority, int newPriority)
public static native void sleep(long millis)
Causes the currently executing thread to sleep (temporarily cease execution) for the specified number of milliseconds. The thread does not lose ownership of any monitors.
param
millis the length of time to sleep in milliseconds.
exception
InterruptedException if another thread has interrupted the current thread. The interrupted status of the current thread is cleared when this exception is thrown.
see
java.lang.Object#notify()
public synchronized void start()
Causes this thread to begin execution; the Java Virtual Machine calls the run method of this thread.
The result is that two threads are running concurrently: the current thread (which returns from the call to the start method) and the other thread (which executes its run method).
exception
IllegalThreadStateException if the thread was already started.
see
java.lang.Thread#run()
start(this);
private static synchronized void start(java.lang.Thread thread)
thread.start0();
private native void start0()
public java.lang.String toString()
Returns a string representation of this thread, including a unique number that identifies the thread and the thread's priority.
return
a string representation of this thread.
return "Thread[@" + hashCode() + "," + getPriority() + "]";
public static native void yield()
Causes the currently executing thread object to temporarily pause and allow other threads to execute.