This class encapsulates all information
about a single thread of control running on the Java interpreter. To
create a thread, you must either pass a Runnable
object (i.e., an object that implements the
Runnable interface by defining a run(
) method) to the Thread constructor or
subclass THRead so that it defines its own
run( ) method. The run( )
method of the Thread or of the specified
Runnable object is the body of the thread. It
begins executing when the start( ) method of the
Thread object is called. The thread runs until the
run( ) method returns. isAlive(
) returns TRue if a thread has been
started, and the run( ) method has not yet exited.
The static methods of this class
operate on the currently running thread. currentThread(
) returns the Thread object of the
currently running code. sleep( ) makes the current
thread stop for a specified amount of time. yield(
) makes the current thread give up control to any other
threads of equal priority that are waiting to run.
holdsLock( ) tests whether the current thread
holds a lock (through a synchronized method or
statement) on the specified object; this Java 1.4 method is often
useful with an assert statement.
The instance methods may be called by
one thread to operate on a different thread. checkAccess(
) checks whether the running thread has permission to
modify a THRead object and throws a
SecurityException if it does not. join(
) waits for a thread to die. interrupt(
) wakes up a waiting or sleeping thread (with an
InterruptedException) or sets an interrupted flag
on a nonsleeping thread. A thread can test its own interrupted flag
with the static interrupted(
) method or can test the flag of another
thread with isInterrupted( ). Calling
interrupted( ) implicitly clears the interrupted
flag, but calling isInterrupted( ) does not.
Methods related to sleep( ) and
interrupt( ) are the wait( )
and notify( ) methods defined by the
Object class. Calling wait( )
causes the current thread to block until the
object's notify( ) method is
called by another thread.
setName( ) sets
the name of a thread, which is purely optional. setPriority(
) sets the priority of the thread. Higher priority threads
run before lower priority threads. Java does not specify what happens
to multiple threads of equal priority; some systems perform
time-slicing and share the CPU between such threads. On other
systems, one compute-bound thread that does not call yield(
) may starve another thread of the same priority.
setDaemon( ) sets a boolean flag that specifies
whether this thread is a daemon or not. The Java VM keeps running as
long as at least one nondaemon thread is running. Call
getThreadGroup( ) to obtain the
ThreadGroup of which a thread is part. In Java 1.2
and later, use setContextClassLoader( ) to specify
the ClassLoader to be used to load any classes
required by the thread.
suspend( ),
resume( ), and stop( ) suspend,
resume, and stop a given thread, respectively, but all three methods
are deprecated because they are inherently unsafe and can cause
deadlock. If a thread must be stoppable, have it periodically check a
flag and exit if the flag is set.
In Java 1.4 and later, the four-argument Thread( )
constructor allows you to specify the "stack
size" parameter for the thread. Typically, larger
stack sizes allow threads to recurse more deeply before running out
of stack space. Smaller stack sizes reduce the fixed per-thread
memory requirements and may allow more threads to exist concurrently.
The meaning of this argument is implementation dependent, and
implementations may even ignore it.
Java 5.0 adds important new features to
this class. getId( ) returns a unique
long
identifier for the thread. getState(
)
returns the state of the thread as an enumerated constant of type
Thread.State.
Thread.UncaughtExceptionHandler
defines an API for handling
exceptions that
cause the run( ) method of the thread to exit.
Register a handler of this type with
setUncaughtExceptionHandler(
) or register a default handler with the static
methods setDefaultUncaughtExceptionHandler(
). Obtain a snapshot of a
thread's current stack trace with
getStackTrace( )
. This returns an array of
StackTraceElement objects: the first element of
the array is the most recent method invocation and the last element
is the least recent. The static getAllStackTraces(
) returns stack traces for all running threads
(the traces may be obtained at different times for different
threads).
Figure 10-63. java.lang.Thread
public class
Thread implements Runnable {
// Public Constructors
public
Thread ( );
public
Thread (String
name );
public
Thread (Runnable
target );
public
Thread (Runnable
target , String
name );
public
Thread (ThreadGroup
group , String
name );
public
Thread (ThreadGroup
group , Runnable
target );
public
Thread (ThreadGroup
group , Runnable
target , String
name );
1.4 public
Thread (ThreadGroup
group , Runnable
target , String
name , long
stackSize );
// Public Constants
public static final int
MAX_PRIORITY ; =10
public static final int
MIN_PRIORITY ; =1
public static final int
NORM_PRIORITY ; =5
// Nested Types
5.0 public enum
State ;
5.0 public interface
UncaughtExceptionHandler ;
// Public Class Methods
public static int
activeCount ( );
public static Thread
currentThread ( ); native
public static void
dumpStack ( );
public static int
enumerate (Thread[ ]
tarray );
5.0 public static java.util.Map<Thread,StackTraceElement[ ]>
getAllStackTraces ( );
5.0 public static Thread.UncaughtExceptionHandler
getDefaultUncaughtExceptionHandler ( );
1.4 public static boolean
holdsLock (Object
obj ); native
public static boolean
interrupted ( );
5.0 public static void
setDefaultUncaughtExceptionHandler (Thread.UncaughtExceptionHandler
eh );
public static void
sleep (long
millis ) throws InterruptedException; native
public static void
sleep (long
millis , int
nanos ) throws InterruptedException;
public static void
yield ( ); native
// Public Instance Methods
public final void
checkAccess ( );
1.2 public ClassLoader
getContextClassLoader ( );
5.0 public long
getId ( ); default:7
public final String
getName ( ); default:"Thread-0"
public final int
getPriority ( ); default:5
5.0 public StackTraceElement[ ]
getStackTrace ( );
5.0 public Thread.State
getState ( );
public final ThreadGroup
getThreadGroup ( );
5.0 public Thread.UncaughtExceptionHandler
getUncaughtExceptionHandler ( ); default:ThreadGroup
public void
interrupt ( );
public final boolean
isAlive ( ); native default:false
public final boolean
isDaemon ( ); default:false
public boolean
isInterrupted ( ); default:false
public final void
join ( ) throws InterruptedException;
public final void
join (long
millis ) throws InterruptedException; synchronized
public final void
join (long
millis , int
nanos ) throws InterruptedException; synchronized
1.2 public void
setContextClassLoader (ClassLoader
cl );
public final void
setDaemon (boolean
on );
public final void
setName (String
name );
public final void
setPriority (int
newPriority );
5.0 public void
setUncaughtExceptionHandler (Thread.UncaughtExceptionHandler
eh );
public void
start ( ); synchronized
// Methods Implementing Runnable
public void
run ( );
// Public Methods Overriding Object
public String
toString ( );
// Deprecated Public Methods
# public int
countStackFrames ( ); native
# public void
destroy ( );
# public final void
resume ( );
# public final void
stop ( );
# public final void
stop (Throwable
obj ); synchronized
# public final void
suspend ( );
}
Runtime.{addShutdownHook( ),
removeShutdownHook( )},
SecurityManager.checkAccess( ),
Thread.UncaughtExceptionHandler.uncaughtException(
), THReadGroup.{enumerate( ),
uncaughtException( )},
java.util.concurrent.ThreadPoolExecutor.beforeExecute(
), java.util.concurrent.TimeUnit.timedJoin(
),
java.util.concurrent.locks.AbstractQueuedSynchronizer.isQueued(
), java.util.concurrent.locks.LockSupport.unpark(
),
java.util.concurrent.locks.ReentrantLock.hasQueuedThread(
),
java.util.concurrent.locks.ReentrantReadWriteLock.hasQueuedThread(
)
java.util.concurrent.ThreadFactory.newThread( ),
java.util.concurrent.locks.AbstractQueuedSynchronizer.getFirstQueuedThread(
),
java.util.concurrent.locks.ReentrantLock.getOwner(
),
java.util.concurrent.locks.ReentrantReadWriteLock.getOwner(
)