|
FlexDoc/Javadoc 2.0 Demo Java Doc |
Every thread has a priority. Threads with higher priority are executed in preference to threads with lower priority. Each thread may or may not also be marked as a daemon. When code running in some thread creates a new Thread object, the new thread has its priority initially set equal to the priority of the creating thread, and is a daemon thread if and only if the creating thread is a daemon.
When a Java Virtual Machine starts up, there is usually a single non-daemon thread (which typically calls the method named main of some designated class). The Java Virtual Machine continues to execute threads until either of the following occurs:
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();
Every thread has a name for identification purposes. More than one thread may have the same name. If a name is not specified when a thread is created, a new name is generated for it.
Unless otherwise noted, passing a null argument to a constructor or method in this class will cause a NullPointerException to be thrown.
Nested Class Summary |
||
static enum |
A thread state.
|
|
static interface |
Interface for handlers invoked when a Thread abruptly
terminates due to an uncaught exception.
|
Field Summary |
||
static final int |
The maximum priority that a thread can have.
|
|
static final int |
The minimum priority that a thread can have.
|
|
static final int |
The default priority that is assigned to a thread.
|
Constructor Summary |
||
Thread()
Allocates a new Thread object.
|
||
Allocates a new Thread object.
|
||
Allocates a new Thread object.
|
||
Allocates a new Thread object.
|
||
Allocates a new Thread object.
|
||
Allocates a new Thread object so that it has target
as its run object, has the specified name as its name,
and belongs to the thread group referred to by group.
|
||
Allocates a new Thread object so that it has target
as its run object, has the specified name as its name,
and belongs to the thread group referred to by group, and has
the specified stack size.
|
||
Thread(ThreadGroup group, Runnable target, String name, long stackSize, boolean inheritThreadLocals)
Allocates a new Thread object so that it has target
as its run object, has the specified name as its name,
belongs to the thread group referred to by group, has
the specified stackSize, and inherits initial values for
inheritable thread-local variables
if inheritThreadLocals is true.
|
||
Allocates a new Thread object.
|
Method Summary |
||
static int |
Returns an estimate of the number of active threads in the current
thread's thread group and its
subgroups.
|
|
final void |
Deprecated, for removal. This method is only useful in conjunction with
the Security Manager, which is
deprecated and subject to removal in a future release.
|
|
protected Object |
clone()
Throws CloneNotSupportedException as a Thread can not be meaningfully
cloned.
|
|
int |
Deprecated, for removal. This method was originally designed to count the number of
stack frames but the results were never well-defined and it
depended on thread-suspension.
|
|
static Thread |
Returns a reference to the currently executing thread object.
|
|
static void |
Prints a stack trace of the current thread to the standard error stream.
|
|
static int |
Copies into the specified array every active thread in the current
thread's thread group and its subgroups.
|
|
Returns a map of stack traces for all live threads.
|
||
Returns the context ClassLoader for this thread.
|
||
Returns the default handler invoked when a thread abruptly terminates
due to an uncaught exception.
|
||
long |
getId()
Returns the identifier of this Thread.
|
|
final String |
getName()
Returns this thread's name.
|
|
final int |
Returns this thread's priority.
|
|
Returns an array of stack trace elements representing the stack dump
of this thread.
|
||
getState()
Returns the state of this thread.
|
||
final ThreadGroup |
Returns the thread group to which this thread belongs.
|
|
Returns the handler invoked when this thread abruptly terminates
due to an uncaught exception.
|
||
static boolean |
Returns true if and only if the current thread holds the
monitor lock on the specified object.
|
|
void |
Interrupts this thread.
|
|
static boolean |
Tests whether the current thread has been interrupted.
|
|
final boolean |
isAlive()
Tests if this thread is alive.
|
|
final boolean |
isDaemon()
Tests if this thread is a daemon thread.
|
|
boolean |
Tests whether this thread has been interrupted.
|
|
final void |
join()
Waits for this thread to die.
|
|
final void |
join(long millis)
Waits at most millis milliseconds for this thread to
die.
|
|
final void |
join(long millis, int nanos)
Waits at most millis milliseconds plus
nanos nanoseconds for this thread to die.
|
|
static void |
Indicates that the caller is momentarily unable to progress, until the
occurrence of one or more actions on the part of other activities.
|
|
final void |
resume()
Deprecated, for removal. This method exists solely for use with suspend(),
which has been deprecated because it is deadlock-prone.
|
|
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.
|
|
void |
Sets the context ClassLoader for this Thread.
|
|
final void |
setDaemon(boolean on)
Marks this thread as either a daemon thread
or a user thread.
|
|
static void |
Set the default handler invoked when a thread abruptly terminates
due to an uncaught exception, and no other handler has been defined
for that thread.
|
|
final void |
Changes the name of this thread to be equal to the argument name.
|
|
final void |
setPriority(int newPriority)
Changes the priority of this thread.
|
|
void |
Set the handler invoked when this thread abruptly terminates
due to an uncaught exception.
|
|
static void |
sleep(long millis)
Causes the currently executing thread to sleep (temporarily cease
execution) for the specified number of milliseconds, subject to
the precision and accuracy of system timers and schedulers.
|
|
static void |
sleep(long millis, int nanos)
Causes the currently executing thread to sleep (temporarily cease
execution) for the specified number of milliseconds plus the specified
number of nanoseconds, subject to the precision and accuracy of system
timers and schedulers.
|
|
void |
start()
Causes this thread to begin execution; the Java Virtual Machine
calls the run method of this thread.
|
|
final void |
stop()
Deprecated. This method is inherently unsafe.
|
|
final void |
suspend()
Deprecated, for removal. This method has been deprecated, as it is
inherently deadlock-prone.
|
|
toString()
Returns a string representation of this thread, including the
thread's name, priority, and thread group.
|
||
static void |
yield()
A hint to the scheduler that the current thread is willing to yield
its current use of a processor.
|
Methods inherited from class java.lang.Object |
public Thread |
() |
public Thread |
(Runnable target) |
public Thread |
public Thread |
(String name) |
public Thread |
public Thread |
public Thread |
If there is a security manager, its checkAccess method is invoked with the ThreadGroup as its argument.
In addition, its checkPermission method is invoked with the RuntimePermission("enableContextClassLoaderOverride") permission when invoked directly or indirectly by the constructor of a subclass which overrides the getContextClassLoader or setContextClassLoader methods.
The priority of the newly created thread is set equal to the priority of the thread creating it, that is, the currently running thread. The method setPriority may be used to change the priority to a new value.
The newly created thread is initially marked as being a daemon thread if and only if the thread creating it is currently marked as a daemon thread. The method setDaemon may be used to change whether or not a thread is a daemon.
public Thread |
This constructor is identical to Thread(ThreadGroup,Runnable,String) with the exception of the fact that it allows the thread stack size to be specified. The stack size is the approximate number of bytes of address space that the virtual machine is to allocate for this thread's stack. The effect of the stackSize parameter, if any, is highly platform dependent.
On some platforms, specifying a higher value for the stackSize parameter may allow a thread to achieve greater recursion depth before throwing a StackOverflowError. Similarly, specifying a lower value may allow a greater number of threads to exist concurrently without throwing an OutOfMemoryError (or other internal error). The details of the relationship between the value of the stackSize parameter and the maximum recursion depth and concurrency level are platform-dependent. On some platforms, the value of the stackSize parameter may have no effect whatsoever.
The virtual machine is free to treat the stackSize parameter as a suggestion. If the specified value is unreasonably low for the platform, the virtual machine may instead use some platform-specific minimum value; if the specified value is unreasonably high, the virtual machine may instead use some platform-specific maximum. Likewise, the virtual machine is free to round the specified value up or down as it sees fit (or to ignore it completely).
Specifying a value of zero for the stackSize parameter will cause this constructor to behave exactly like the Thread(ThreadGroup, Runnable, String) constructor.
Due to the platform-dependent nature of the behavior of this constructor, extreme care should be exercised in its use. The thread stack size necessary to perform a given computation will likely vary from one JRE implementation to another. In light of this variation, careful tuning of the stack size parameter may be required, and the tuning may need to be repeated for each JRE implementation on which an application is to run.
Implementation note: Java platform implementers are encouraged to document their implementation's behavior with respect to the stackSize parameter.
public Thread |
This constructor is identical to Thread(ThreadGroup,Runnable,String,long) with the added ability to suppress, or not, the inheriting of initial values for inheritable thread-local variables from the constructing thread. This allows for finer grain control over inheritable thread-locals. Care must be taken when passing a value of false for inheritThreadLocals, as it may lead to unexpected behavior if the new thread executes code that expects a specific thread-local value to be inherited.
Specifying a value of true for the inheritThreadLocals parameter will cause this constructor to behave exactly like the Thread(ThreadGroup, Runnable, String, long) constructor.
public static Thread currentThread |
() |
public static void yield |
() |
Yield is a heuristic attempt to improve relative progression between threads that would otherwise over-utilise a CPU. Its use should be combined with detailed profiling and benchmarking to ensure that it actually has the desired effect.
It is rarely appropriate to use this method. It may be useful for debugging or testing purposes, where it may help to reproduce bugs due to race conditions. It may also be useful when designing concurrency control constructs such as the ones in the java.util.concurrent.locks package.
public static void sleep |
(long millis) |
throws |
public static void sleep |
(long millis, int nanos) |
throws |
public static void onSpinWait |
() |
protected Object clone |
() |
throws |
public void start |
() |
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).
It is never legal to start a thread more than once. In particular, a thread may not be restarted once it has completed execution.
public void run |
() |
Subclasses of Thread should override this method.
public final void stop |
() |
If there is a security manager installed, its checkAccess method is called with this as its argument. This may result in a SecurityException being raised (in the current thread).
If this thread is different from the current thread (that is, the current thread is trying to stop a thread other than itself), the security manager's checkPermission method (with a RuntimePermission("stopThread") argument) is called in addition. Again, this may result in throwing a SecurityException (in the current thread).
The thread represented by this thread is forced to stop whatever it is doing abnormally and to throw a newly created ThreadDeath object as an exception.
It is permitted to stop a thread that has not yet been started. If the thread is eventually started, it immediately terminates.
An application should not normally try to catch ThreadDeath unless it must do some extraordinary cleanup operation (note that the throwing of ThreadDeath causes finally clauses of try statements to be executed before the thread officially dies). If a catch clause catches a ThreadDeath object, it is important to rethrow the object so that the thread actually dies.
The top-level error handler that reacts to otherwise uncaught exceptions does not print out a message or otherwise notify the application if the uncaught exception is an instance of ThreadDeath.
public void interrupt |
() |
Unless the current thread is interrupting itself, which is always permitted, the checkAccess method of this thread is invoked, which may cause a SecurityException to be thrown.
If this thread is blocked in an invocation of the wait(), wait(long), or wait(long, int) methods of the Object class, or of the join(), join(long), join(long, int), sleep(long), or sleep(long, int) methods of this class, then its interrupt status will be cleared and it will receive an InterruptedException.
If this thread is blocked in an I/O operation upon an InterruptibleChannel then the channel will be closed, the thread's interrupt status will be set, and the thread will receive a ClosedByInterruptException.
If this thread is blocked in a Selector then the thread's interrupt status will be set and it will return immediately from the selection operation, possibly with a non-zero value, just as if the selector's wakeup method were invoked.
If none of the previous conditions hold then this thread's interrupt status will be set.
Interrupting a thread that is not alive need not have any effect.
public static boolean interrupted |
() |
public boolean isInterrupted |
() |
public final boolean isAlive |
() |
public final void suspend |
() |
First, the checkAccess method of this thread is called with no arguments. This may result in throwing a SecurityException (in the current thread).
If the thread is alive, it is suspended and makes no further progress unless and until it is resumed.
public final void resume |
() |
First, the checkAccess method of this thread is called with no arguments. This may result in throwing a SecurityException (in the current thread).
If the thread is alive but suspended, it is resumed and is permitted to make progress in its execution.
public final void setPriority |
(int newPriority) |
First the checkAccess method of this thread is called with no arguments. This may result in throwing a SecurityException.
Otherwise, the priority of this thread is set to the smaller of the specified newPriority and the maximum permitted priority of the thread's thread group.
public final int getPriority |
() |
public final void setName |
(String name) |
First the checkAccess method of this thread is called with no arguments. This may result in throwing a SecurityException.
public final String getName |
() |
public final ThreadGroup getThreadGroup |
() |
public static int activeCount |
() |
The value returned is only an estimate because the number of threads may change dynamically while this method traverses internal data structures, and might be affected by the presence of certain system threads. This method is intended primarily for debugging and monitoring purposes.
public static int enumerate |
(Thread[] tarray) |
An application might use the activeCount method to get an estimate of how big the array should be, however if the array is too short to hold all the threads, the extra threads are silently ignored. If it is critical to obtain every active thread in the current thread's thread group and its subgroups, the invoker should verify that the returned int value is strictly less than the length of tarray.
Due to the inherent race condition in this method, it is recommended that the method only be used for debugging and monitoring purposes.
public int countStackFrames |
() |
public final void join |
(long millis) |
throws |
This implementation uses a loop of this.wait calls conditioned on this.isAlive. As a thread terminates the this.notifyAll method is invoked. It is recommended that applications not use wait, notify, or notifyAll on Thread instances.
public final void join |
(long millis, int nanos) |
throws |
This implementation uses a loop of this.wait calls conditioned on this.isAlive. As a thread terminates the this.notifyAll method is invoked. It is recommended that applications not use wait, notify, or notifyAll on Thread instances.
public final void join |
() |
throws |
An invocation of this method behaves in exactly the same way as the invocation
join(0)
public static void dumpStack |
() |
public final void setDaemon |
(boolean on) |
This method must be invoked before the thread is started.
public final boolean isDaemon |
() |
public final void checkAccess |
() |
If there is a security manager, its checkAccess method is called with this thread as its argument. This may result in throwing a SecurityException.
public String toString |
() |
public ClassLoader getContextClassLoader |
() |
public void setContextClassLoader |
(ClassLoader cl) |
If a security manager is present, its checkPermission method is invoked with a RuntimePermission ("setContextClassLoader") permission to see if setting the context ClassLoader is permitted.
public static boolean holdsLock |
(Object obj) |
This method is designed to allow a program to assert that the current thread already holds a specified lock:
assert Thread.holdsLock(obj);
public StackTraceElement[] getStackTrace |
() |
If there is a security manager, and this thread is not the current thread, then the security manager's checkPermission method is called with a RuntimePermission("getStackTrace") permission to see if it's ok to get the stack trace.
Some virtual machines may, under some circumstances, omit one or more stack frames from the stack trace. In the extreme case, a virtual machine that has no stack trace information concerning this thread is permitted to return a zero-length array from this method.
() |
The threads may be executing while this method is called. The stack trace of each thread only represents a snapshot and each stack trace may be obtained at different time. A zero-length array will be returned in the map value if the virtual machine has no stack trace information about a thread.
If there is a security manager, then the security manager's checkPermission method is called with a RuntimePermission("getStackTrace") permission as well as RuntimePermission("modifyThreadGroup") permission to see if it is ok to get the stack trace of all threads.
public long getId |
() |
public Thread.State getState |
() |
public static void setDefaultUncaughtExceptionHandler |
Uncaught exception handling is controlled first by the thread, then by the thread's ThreadGroup object and finally by the default uncaught exception handler. If the thread does not have an explicit uncaught exception handler set, and the thread's thread group (including parent thread groups) does not specialize its uncaughtException method, then the default handler's uncaughtException method will be invoked.
By setting the default uncaught exception handler, an application can change the way in which uncaught exceptions are handled (such as logging to a specific device, or file) for those threads that would already accept whatever "default" behavior the system provided.
Note that the default uncaught exception handler should not usually defer to the thread's ThreadGroup object, as that could cause infinite recursion.
public static Thread.UncaughtExceptionHandler getDefaultUncaughtExceptionHandler |
() |
public Thread.UncaughtExceptionHandler getUncaughtExceptionHandler |
() |
public void setUncaughtExceptionHandler |
A thread can take full control of how it responds to uncaught exceptions by having its uncaught exception handler explicitly set. If no such handler is set then the thread's ThreadGroup object acts as its handler.
|
FlexDoc/Javadoc 2.0 Demo Java Doc |