Class Thread

public static final int MAX_PRIORITY

The maximum priority for a Thread.

Field Value:

10

public static final int MIN_PRIORITY

The minimum priority for a Thread.

Field Value:

1

public static final int NORM_PRIORITY

The priority a Thread gets by default.

Field Value:

5

public Thread()

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 Also:

Thread(ThreadGroup,Runnable,String)

public Thread(Runnable target)

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.

Parameters:

target - the object whose run method is called.

See Also:

Thread(ThreadGroup,Runnable,String)

public Thread(Runnable target,
              String name)

Allocates a new Thread object. This constructor has the same effect as Thread(null, target, name).

Parameters:

target - the Runnable object to execute

name - the name for the Thread

Throws:

NullPointerException - if name is null

See Also:

Thread(ThreadGroup,Runnable,String)

public Thread(String name)

Allocates a new Thread object. This constructor has the same effect as Thread(null, null, name).

Parameters:

name - the name of the new thread.

See Also:

Thread(ThreadGroup,Runnable,String)

public Thread(ThreadGroup group,
              Runnable target)

Allocates a new Thread object. This constructor has the same effect as Thread(group, target, gname), where gname is a newly generated name. Automatically generated names are of the form "Thread-"+n, where n is an integer.

Parameters:

group - the group to put the Thread into

target - the Runnable object to execute

Throws:

SecurityException - if this thread cannot access group

IllegalThreadStateException - if group is destroyed

See Also:

Thread(ThreadGroup,Runnable,String)

public Thread(ThreadGroup group,
              Runnable target,
              String name)

Allocate a new Thread object, with the specified ThreadGroup and name, and using the specified Runnable object's run() method to execute. If the Runnable object is null, this (which is a Runnable) is used instead.

If the ThreadGroup is null, the security manager is checked. If a manager exists and returns a non-null object for getThreadGroup, that group is used; otherwise the group of the creating thread is used. Note that the security manager calls checkAccess if the ThreadGroup is not null.

The new Thread will inherit its creator's priority and daemon status. These can be changed with setPriority and setDaemon.

Parameters:

group - the group to put the Thread into

target - the Runnable object to execute

name - the name for the Thread

Throws:

NullPointerException - if name is null

SecurityException - if this thread cannot access group

IllegalThreadStateException - if group is destroyed

See Also:

Runnable.run(), run(), setDaemon(boolean), setPriority(int), SecurityManager.checkAccess(ThreadGroup), ThreadGroup.checkAccess()

public Thread(ThreadGroup group,
              Runnable target,
              String name,
              long size)

Allocate a new Thread object, as if by Thread(group, null, name), and give it the specified stack size, in bytes. The stack size is highly platform independent, and the virtual machine is free to round up or down, or ignore it completely. A higher value might let you go longer before a StackOverflowError, while a lower value might let you go longer before an OutOfMemoryError. Or, it may do absolutely nothing! So be careful, and expect to need to tune this value if your virtual machine even supports it.

Parameters:

group - the group to put the Thread into

target - the Runnable object to execute

name - the name for the Thread

size - the stack size, in bytes; 0 to be ignored

Throws:

NullPointerException - if name is null

SecurityException - if this thread cannot access group

IllegalThreadStateException - if group is destroyed

Since:

1.4

public Thread(ThreadGroup group,
              String name)

Allocates a new Thread object. This constructor has the same effect as Thread(group, null, name)

Parameters:

group - the group to put the Thread into

name - the name for the Thread

Throws:

NullPointerException - if name is null

SecurityException - if this thread cannot access group

IllegalThreadStateException - if group is destroyed

See Also:

Thread(ThreadGroup,Runnable,String)

public static MapStackTraceElement[]> getAllStackTraces()

Returns a map of threads to stack traces for each live thread. The keys of the map are Thread objects, which map to arrays of StackTraceElements. The results obtained from Calling this method are equivalent to calling getStackTrace() on each thread in succession. Threads may be executing while this takes place, and the results represent a snapshot of the thread at the time its getStackTrace() method is called.

The stack trace information contains the methods called by the thread, with the most recent method forming the first element in the array. The array will be empty if the virtual machine can not obtain information on the thread.

To execute this method, the current security manager (if one exists) must allow both the "getStackTrace" and "modifyThreadGroup" RuntimePermissions.

Returns:

a map of threads to arrays of StackTraceElements.

Throws:

SecurityException - if a security manager exists, and prevents either or both the runtime permissions specified above.

Since:

1.5

See Also:

getStackTrace()

public static int activeCount()

Get the number of active threads in the current Thread's ThreadGroup. This implementation calls currentThread().getThreadGroup().activeCount().

Returns:

the number of active threads in the current ThreadGroup

See Also:

ThreadGroup.activeCount()

public final void checkAccess()

Check whether the current Thread is allowed to modify this Thread. This passes the check on to SecurityManager.checkAccess(this).

Throws:

SecurityException - if the current Thread cannot modify this Thread

See Also:

SecurityManager.checkAccess(Thread)

public int countStackFrames()

Deprecated. pointless, since suspend is deprecated

Count the number of stack frames in this Thread. The Thread in question must be suspended when this occurs.

Returns:

the number of stack frames in this Thread

Throws:

IllegalThreadStateException - if this Thread is not suspended

public static Thread currentThread()

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.

Returns:

the currently executing Thread

public void destroy()

Deprecated. This method was originally intended to simply destroy the thread without performing any form of cleanup operation. However, it was never implemented. It is now deprecated for the same reason as suspend(), stop() and resume(); namely, it is prone to deadlocks. If a thread is destroyed while it still maintains a lock on a resource, then this resource will remain locked and any attempts by other threads to access the resource will result in a deadlock. Thus, even an implemented version of this method would be still be deprecated, due to its unsafe nature.

Originally intended to destroy this thread, this method was never implemented by Sun, and is hence a no-op.

public static void dumpStack()

Print a stack trace of the current thread to stderr using the same format as Throwable's printStackTrace() method.

See Also:

Throwable.printStackTrace()

public static int enumerate(Thread[] array)

Copy every active thread in the current Thread's ThreadGroup into the array. Extra threads are silently ignored. This implementation calls getThreadGroup().enumerate(array), which may have a security check, checkAccess(group).

Parameters:

array - the array to place the Threads into

Returns:

the number of Threads placed into the array

Throws:

NullPointerException - if array is null

SecurityException - if you cannot access the ThreadGroup

See Also:

ThreadGroup.enumerate(Thread[]), activeCount(), SecurityManager.checkAccess(ThreadGroup)

public ClassLoader getContextClassLoader()

Returns the context classloader of this Thread. The context classloader can be used by code that want to load classes depending on the current thread. Normally classes are loaded depending on the classloader of the current class. There may be a security check for RuntimePermission("getClassLoader") if the caller's class loader is not null or an ancestor of this thread's context class loader.

Returns:

the context class loader

Throws:

SecurityException - when permission is denied

Since:

1.2

See Also:

setContextClassLoader(ClassLoader)

public static Thread.UncaughtExceptionHandler getDefaultUncaughtExceptionHandler()

Returns the handler used by default when a thread terminates unexpectedly due to an exception, or null if one doesn't exist.

Returns:

the default uncaught exception handler.

Since:

1.5

public long getId()

Returns the unique identifier for this thread. This ID is generated on thread creation, and may be re-used on its death.

Returns:

a positive long number representing the thread's ID.

Since:

1.5

public final String getName()

Get this Thread's name.

Returns:

this Thread's name

public final int getPriority()

Get this Thread's priority.

Returns:

the Thread's priority

public StackTraceElement[] getStackTrace()

Returns an array of StackTraceElements representing the current stack trace of this thread. The first element of the array is the most recent method called, and represents the top of the stack. The elements continue in this order, with the last element representing the bottom of the stack.

A zero element array is returned for threads which have not yet started (and thus have not yet executed any methods) or for those which have terminated. Where the virtual machine can not obtain a trace for the thread, an empty array is also returned. The virtual machine may also omit some methods from the trace in non-zero arrays.

To execute this method, the current security manager (if one exists) must allow both the "getStackTrace" and "modifyThreadGroup" RuntimePermissions.

Returns:

a stack trace for this thread.

Throws:

SecurityException - if a security manager exists, and prevents the use of the "getStackTrace" permission.

Since:

1.5

See Also:

getAllStackTraces()

public Thread.State getState()

Returns the current state of the thread. This is designed for monitoring thread behaviour, rather than for synchronization control.

Returns:

the current thread state.

public final ThreadGroup getThreadGroup()

Get the ThreadGroup this Thread belongs to. If the thread has died, this returns null.

Returns:

this Thread's ThreadGroup

public Thread.UncaughtExceptionHandler getUncaughtExceptionHandler()

Returns the handler used when this thread terminates due to an uncaught exception. The handler used is determined by the following:

• If this thread has its own handler, this is returned.
• If not, then the handler of the thread's ThreadGroup object is returned.
• If both are unavailable, then null is returned (which can only happen when the thread was terminated since then it won't have an associated thread group anymore).

Returns:

the appropriate UncaughtExceptionHandler or null if one can't be obtained.

Since:

1.5

public static boolean holdsLock(Object obj)

Checks whether the current thread holds the monitor on a given object. This allows you to do assert Thread.holdsLock(obj).

Parameters:

obj - the object to test lock ownership on.

Returns:

true if the current thread is currently synchronized on obj

Throws:

NullPointerException - if obj is null

Since:

1.4

public void interrupt()

Interrupt this Thread. First, there is a security check, checkAccess. Then, depending on the current state of the thread, various actions take place:

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().

If the thread is blocked in an interruptible I/O operation, in InterruptibleChannel, the interrupt status will be set, and ClosedByInterruptException will be thrown.

If the thread is blocked on a Selector, the interrupt status will be set, and the selection will return, with a possible non-zero value, as though by the wakeup() method.

Otherwise, the interrupt status will be set.

Throws:

SecurityException - if you cannot modify this Thread

public static boolean interrupted()

Determine whether the current Thread has been interrupted, and clear the interrupted status in the process.

Returns:

whether the current Thread has been interrupted

See Also:

isInterrupted()

public final boolean isAlive()

Determine whether this Thread is alive. A thread which is alive has started and not yet died.

Returns:

whether this Thread is alive

public final boolean isDaemon()

Tell whether this is a daemon Thread or not.

Returns:

whether this is a daemon Thread or not

See Also:

setDaemon(boolean)

public boolean isInterrupted()

Determine whether the given Thread has been interrupted, but leave the interrupted status alone in the process.

Returns:

whether the Thread has been interrupted

See Also:

interrupted()

public final void join()
            throws InterruptedException

Wait forever for the Thread in question to die.

Throws:

InterruptedException - if the Thread is interrupted; it's interrupted status will be cleared

public final void join(long ms)
            throws InterruptedException

Wait the specified amount of time for the Thread in question to die.

Parameters:

ms - the number of milliseconds to wait, or 0 for forever

Throws:

InterruptedException - if the Thread is interrupted; it's interrupted status will be cleared

public final void join(long ms,
                       int ns)
            throws InterruptedException

Wait the specified amount of time for the Thread in question to die.

Note that 1,000,000 nanoseconds == 1 millisecond, but most VMs do not offer that fine a grain of timing resolution. Besides, there is no guarantee that this thread can start up immediately when time expires, because some other thread may be active. So don't expect real-time performance.

Parameters:

ms - the number of milliseconds to wait, or 0 for forever

ns - the number of extra nanoseconds to sleep (0-999999)

Throws:

InterruptedException - if the Thread is interrupted; it's interrupted status will be cleared

IllegalArgumentException - if ns is invalid

public final void resume()

Deprecated. pointless, since suspend is deprecated

Resume this Thread. If the thread is not suspended, this method does nothing. To mirror suspend(), there may be a security check: checkAccess.

Throws:

SecurityException - if you cannot resume the Thread

See Also:

checkAccess(), suspend()

public void run()

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.

Specified by:

run in interface Runnable

See Also:

start(), Thread(ThreadGroup,Runnable,String)

public void setContextClassLoader(ClassLoader classloader)

Sets the context classloader for this Thread. When not explicitly set, the context classloader for a thread is the same as the context classloader of the thread that created this thread. The first thread has as context classloader the system classloader. There may be a security check for RuntimePermission("setContextClassLoader").

Parameters:

classloader - the new context class loader

Throws:

SecurityException - when permission is denied

Since:

1.2

See Also:

getContextClassLoader()

public final void setDaemon(boolean daemon)

Set the daemon status of this Thread. If this is a daemon Thread, then the VM may exit even if it is still running. This may only be called before the Thread starts running. There may be a security check, checkAccess.

Parameters:

daemon - whether this should be a daemon thread or not

Throws:

SecurityException - if you cannot modify this Thread

IllegalThreadStateException - if the Thread is active

See Also:

isDaemon(), checkAccess()

public static void setDefaultUncaughtExceptionHandler(Thread.UncaughtExceptionHandler h)

Sets the default uncaught exception handler used when one isn't provided by the thread or its associated ThreadGroup. This exception handler is used when the thread itself does not have an exception handler, and the thread's ThreadGroup does not override this default mechanism with its own. As the group calls this handler by default, this exception handler should not defer to that of the group, as it may lead to infinite recursion.

Uncaught exception handlers are used when a thread terminates due to an uncaught exception. Replacing this handler allows default code to be put in place for all threads in order to handle this eventuality.

Parameters:

h - the new default uncaught exception handler to use.

Throws:

SecurityException - if a security manager is present and disallows the runtime permission "setDefaultUncaughtExceptionHandler".

Since:

1.5

public final void setName(String name)

Set this Thread's name. There may be a security check, checkAccess.

Parameters:

name - the new name for this Thread

Throws:

NullPointerException - if name is null

SecurityException - if you cannot modify this Thread

public final void setPriority(int newPriority)

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.

Parameters:

Throws:

IllegalArgumentException - if priority exceeds MIN_PRIORITY or MAX_PRIORITY

SecurityException - if you cannot modify this Thread

See Also:

getPriority(), checkAccess(), ThreadGroup.getMaxPriority(), MIN_PRIORITY, MAX_PRIORITY

public void setUncaughtExceptionHandler(Thread.UncaughtExceptionHandler h)

Assigns the given UncaughtExceptionHandler to this thread. This will then be called if the thread terminates due to an uncaught exception, pre-empting that of the ThreadGroup.

Parameters:

h - the handler to use for this thread.

Throws:

SecurityException - if the current thread can't modify this thread.

Since:

1.5

public static void sleep(long ms)
            throws InterruptedException

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.

Parameters:

ms - the number of milliseconds to sleep, or 0 for forever

Throws:

InterruptedException - if the Thread is (or was) interrupted; it's interrupted status will be cleared

IllegalArgumentException - if ms is negative

See Also:

interrupt(), notify(), wait(long)

public static void sleep(long timeout,
                         int nanos)
            throws InterruptedException

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.

Note that 1,000,000 nanoseconds == 1 millisecond, but most VMs do not offer that fine a grain of timing resolution. When ms is zero and ns is non-zero the Thread will sleep for at least one milli second. There is no guarantee that this thread can start up immediately when time expires, because some other thread may be active. So don't expect real-time performance.

Parameters:

Throws:

InterruptedException - if the Thread is (or was) interrupted; it's interrupted status will be cleared

IllegalArgumentException - if ms or ns is negative or ns is larger than 999999.

See Also:

interrupt(), notify(), wait(long,int)

public void start()

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. The virtual machine will remove the thread from its thread group when the run() method completes.

Throws:

IllegalThreadStateException - if the thread has already started

See Also:

run()

public final void stop()

Deprecated. unsafe operation, try not to use

Cause this Thread to stop abnormally because of the throw of a ThreadDeath error. If you stop a Thread that has not yet started, it will stop immediately when it is actually started.

This is inherently unsafe, as it can interrupt synchronized blocks and leave data in bad states. Hence, there is a security check: checkAccess(this), plus another one if the current thread is not this: RuntimePermission("stopThread"). If you must catch a ThreadDeath, be sure to rethrow it after you have cleaned up. ThreadDeath is the only exception which does not print a stack trace when the thread dies.

Throws:

SecurityException - if you cannot stop the Thread

See Also:

interrupt(), checkAccess(), start(), ThreadDeath, ThreadGroup.uncaughtException(Thread,Throwable), SecurityManager.checkAccess(Thread), SecurityManager.checkPermission(Permission)

public final void stop(Throwable t)

Deprecated. unsafe operation, try not to use

Cause this Thread to stop abnormally and throw the specified exception. If you stop a Thread that has not yet started, the stop is ignored (contrary to what the JDK documentation says). WARNINGThis bypasses Java security, and can throw a checked exception which the call stack is unprepared to handle. Do not abuse this power.

This is inherently unsafe, as it can interrupt synchronized blocks and leave data in bad states. Hence, there is a security check: checkAccess(this), plus another one if the current thread is not this: RuntimePermission("stopThread"). If you must catch a ThreadDeath, be sure to rethrow it after you have cleaned up. ThreadDeath is the only exception which does not print a stack trace when the thread dies.

Parameters:

t - the Throwable to throw when the Thread dies

Throws:

SecurityException - if you cannot stop the Thread

NullPointerException - in the calling thread, if t is null

See Also:

interrupt(), checkAccess(), start(), ThreadDeath, ThreadGroup.uncaughtException(Thread,Throwable), SecurityManager.checkAccess(Thread), SecurityManager.checkPermission(Permission)

public final void suspend()

Deprecated. unsafe operation, try not to use

Suspend this Thread. It will not come back, ever, unless it is resumed.

This is inherently unsafe, as the suspended thread still holds locks, and can potentially deadlock your program. Hence, there is a security check: checkAccess.

Throws:

SecurityException - if you cannot suspend the Thread

See Also:

checkAccess(), resume()

public String toString()

Returns a string representation of this thread, including the thread's name, priority, and thread group.

Overrides:

toString in interface Object

Returns:

a human-readable String representing this Thread

public static void yield()

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.