Threads have names to identify them. These names are not necessarily * unique. Every Thread has a priority, as well, which tells the VM which * Threads should get more running time. New threads inherit the priority * and daemon status of the parent thread, by default. * *
There are two methods of creating a Thread: you may subclass Thread and
* implement the run() method, at which point you may start the
* Thread by calling its start() method, or you may implement
* Runnable in the class you want to use and then call new
* Thread(your_obj).start().
*
*
The virtual machine runs until all non-daemon threads have died (either
* by returning from the run() method as invoked by start(), or by throwing
* an uncaught exception); or until System.exit is called with
* adequate permissions.
*
*
It is unclear at what point a Thread should be added to a ThreadGroup,
* and at what point it should be removed. Should it be inserted when it
* starts, or when it is created? Should it be removed when it is suspended
* or interrupted? The only thing that is clear is that the Thread should be
* removed when it is stopped.
*
* @author Tom Tromey
* @author John Keiser
* @author Eric Blake (ebb9@email.byu.edu)
* @see Runnable
* @see Runtime#exit(int)
* @see #run()
* @see #start()
*/
public class Thread implements Runnable
{
/** The minimum priority for a Thread. */
public static final int MIN_PRIORITY = 1;
/** The priority a Thread gets by default. */
public static final int NORM_PRIORITY = 5;
/** The maximum priority for a Thread. */
public static final int MAX_PRIORITY = 10;
/** The object to run(), null if this is the target. */
final Runnable runnable;
/** The thread name, non-null. */
volatile String name;
/** The internal thread representation */
volatile VMPointer vmThread;
/** The thread priority, 1 to 10. */
volatile int priority;
/** The next thread number to use. */
private static int numAnonymousThreadsCreated = 0;
/**
* Allocates a new Thread object. This constructor has
* the same effect as Thread(null, null,
* gname), where gname is
* a newly generated name. Automatically generated names are of the
* form "Thread-"+n, where n is an integer.
*
* Threads created this way must have overridden their
* run() method to actually do anything. An example
* illustrating this method being used follows:
*
* import java.lang.*;
*
* class plain01 implements Runnable {
* String name;
* plain01() {
* name = null;
* }
* plain01(String s) {
* name = s;
* }
* public void run() {
* if (name == null)
* System.out.println("A new thread created");
* else
* System.out.println("A new thread with name " + name +
* " created");
* }
* }
* class threadtest01 {
* public static void main(String args[] ) {
* int failed = 0 ;
*
* Thread t1 = new Thread();
* if (t1 != null)
* System.out.println("new Thread() succeed");
* else {
* System.out.println("new Thread() failed");
* failed++;
* }
* }
* }
*
*
* @see java.lang.Thread#Thread(java.lang.ThreadGroup,
* java.lang.Runnable, java.lang.String)
*/
public Thread()
{
this((Runnable) null, createAnonymousThreadName());
}
/**
* Allocates a new Thread object. This constructor has
* the same effect as Thread(null, target,
* gname), where gname is
* a newly generated name. Automatically generated names are of the
* form "Thread-"+n, where n is an integer.
*
* @param target the object whose run method is called.
*/
public Thread(Runnable target)
{
this(target, createAnonymousThreadName());
}
/**
* Allocates a new Thread object. This constructor has
* the same effect as Thread(null, null, name).
*
* @param name the name of the new thread.
*/
public Thread(String name)
{
this(null, name);
}
/**
* Allocates a new Thread object. This constructor has
* the same effect as Thread(null, target, name).
*
* @param target the Runnable object to execute
* @param name the name for the Thread
* @throws NullPointerException if name is null
*/
public Thread(Runnable target, String name)
{
Thread current = currentThread();
// Use toString hack to detect null.
this.name = name.toString();
this.runnable = target;
priority = current.priority;
}
/**
* Generate a name for an anonymous thread.
*/
private static synchronized String createAnonymousThreadName()
{
return "Thread-" + ++numAnonymousThreadsCreated;
}
/**
* Get the currently executing Thread. In the situation that the
* currently running thread was created by native code and doesn't
* have an associated Thread object yet, a new Thread object is
* constructed and associated with the native thread.
*
* @return the currently executing Thread
*/
public native static Thread currentThread();
/**
* Yield to another thread. The Thread will not lose any locks it holds
* during this time. There are no guarantees which thread will be
* next to run, and it could even be this one, but most VMs will choose
* the highest priority thread that has been waiting longest.
*/
public native static void yield();
/**
* Suspend the current Thread's execution for the specified amount of
* time. The Thread will not lose any locks it has during this time. There
* are no guarantees which thread will be next to run, but most VMs will
* choose the highest priority thread that has been waiting longest.
*
* @param ms the number of milliseconds to sleep.
* @throws InterruptedException if the Thread is (or was) interrupted;
* it's interrupted status will be cleared
* @throws IllegalArgumentException if ms is negative
* @see #interrupt()
*/
public native static void sleep(long ms) throws InterruptedException;
/**
* Start this Thread, calling the run() method of the Runnable this Thread
* was created with, or else the run() method of the Thread itself. This
* is the only way to start a new thread; calling run by yourself will just
* stay in the same thread. This method implicitly sets vmThread.
*
* @throws IllegalThreadStateException if the thread has already started
* @see #run()
*/
public synchronized native void start();
/**
* The method of Thread that will be run if there is no Runnable object
* associated with the Thread. Thread's implementation does nothing at all.
*/
public void run()
{
if (runnable != null)
runnable.run();
}
/**
* Interrupt this Thread.
*
* If the thread is waiting because of wait(), * sleep(long), or join(), its interrupt status * will be cleared, and an InterruptedException will be thrown. Notice that * this case is only possible if an external thread called interrupt(). * *
Otherwise, the interrupt status will be set.
*/
public synchronized native void interrupt();
/**
* Determine whether this Thread is alive. A thread which is alive has
* started and not yet died.
*
* @return whether this Thread is alive
*/
public final synchronized boolean isAlive()
{
return vmThread != null;
}
/**
* Set this Thread's priority. There may be a security check,
* checkAccess, then the priority is set to the smaller of
* priority and the ThreadGroup maximum priority.
*
* @param priority the new priority for this Thread
* @throws IllegalArgumentException if priority exceeds MIN_PRIORITY or
* MAX_PRIORITY
* @throws SecurityException if you cannot modify this Thread
*/
public final synchronized void setPriority(int priority)
{
if (priority < MIN_PRIORITY || priority > MAX_PRIORITY)
throw new IllegalArgumentException();
this.priority = priority;
}
/**
* Get this Thread's priority.
*
* @return the Thread's priority
*/
public final synchronized int getPriority()
{
return priority;
}
/**
* Get this Thread's name.
*
* @return this Thread's name
*/
public final String getName()
{
return name;
}
/**
* Returns the current number of active threads in the virtual machine
*
* @return the current number of active threads
*/
public native static int activeCount();
/**
* Wait forever for the Thread in question to die.
*
* @throws InterruptedException if the Thread is interrupted; it's
* interrupted status will be cleared
*/
public native final void join() throws InterruptedException;
/**
* Returns a string representation of this thread, including the
* thread's name, priority, and thread group.
*
* @return a human-readable String representing this Thread
*/
public String toString()
{
return ("Thread[" + name + "," + priority + "]");
}
}