IT. Expert System.

Android Reference

Thread

java.lang

Class Thread

java.lang.Object
- java.lang.Thread

All Implemented Interfaces:

Runnable

Direct Known Subclasses:

AnimationThread, DeleteOnExit, ForkJoinWorkerThread, HandlerTester, HandlerThread, LowLevelNetRunner
```
public class Thread
extends Object
implements Runnable
```
A Thread is a concurrent unit of execution. It has its own call stack for methods being invoked, their arguments and local variables. Each virtual machine instance has at least one main Thread running when it is started; typically, there are several others for housekeeping. The application might decide to launch additional Threads for specific purposes.
Threads in the same VM interact and synchronize by the use of shared objects and monitors associated with these objects. Synchronized methods and part of the API in Object also allow Threads to cooperate.
There are basically two main ways of having a Thread execute application code. One is providing a new class that extends Thread and overriding its run() method. The other is providing a new Thread instance with a Runnable object during its creation. In both cases, the start() method must be called to actually execute the new Thread.
Each Thread has an integer priority that basically determines the amount of CPU time the Thread gets. It can be set using the setPriority(int) method. A Thread can also be made a daemon, which makes it run in the background. The latter also affects VM termination behavior: the VM does not terminate automatically as long as there are non-daemon threads running.

See Also:
Object, ThreadGroup

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`Thread.State` A representation of a thread's state.
`static interface`	`Thread.UncaughtExceptionHandler` Implemented by objects that want to handle cases where a thread is being terminated by an uncaught exception.

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`MAX_PRIORITY` The maximum priority value allowed for a thread.
`static int`	`MIN_PRIORITY` The minimum priority value allowed for a thread.
`static int`	`NORM_PRIORITY` The normal (default) priority value assigned to threads.

Constructor Summary

Constructors
Constructor and Description
`Thread()` Constructs a new `Thread` with no `Runnable` object and a newly generated name.
`Thread(Runnable runnable)` Constructs a new `Thread` with a `Runnable` object and a newly generated name.
`Thread(Runnable runnable, String threadName)` Constructs a new `Thread` with a `Runnable` object and name provided.
`Thread(String threadName)` Constructs a new `Thread` with no `Runnable` object and the name provided.
`Thread(ThreadGroup group, Runnable runnable)` Constructs a new `Thread` with a `Runnable` object and a newly generated name.
`Thread(ThreadGroup group, Runnable runnable, String threadName)` Constructs a new `Thread` with a `Runnable` object, the given name and belonging to the `ThreadGroup` passed as parameter.
`Thread(ThreadGroup group, Runnable runnable, String threadName, long stackSize)` Constructs a new `Thread` with a `Runnable` object, the given name and belonging to the `ThreadGroup` passed as parameter.
`Thread(ThreadGroup group, String threadName)` Constructs a new `Thread` with no `Runnable` object, the given name and belonging to the `ThreadGroup` passed as parameter.

Method Summary

Methods
Modifier and Type	Method and Description
`static int`	`activeCount()` Returns the number of active `Thread`s in the running `Thread`'s group and its subgroups.
`void`	`checkAccess()` Does nothing.
`int`	`countStackFrames()` Deprecated. The results of this call were never well defined. To make things worse, it would depend on whether the Thread was suspended or not, and suspend was deprecated too.
`static Thread`	`currentThread()` Returns the Thread of the caller, that is, the current Thread.
`void`	`destroy()` Deprecated. Not implemented.
`static void`	`dumpStack()` Prints to the standard error stream a text representation of the current stack for this Thread.
`static int`	`enumerate(Thread[] threads)` Copies an array with all Threads which are in the same ThreadGroup as the receiver - and subgroups - into the array `threads` passed as parameter.
`static Map<Thread,StackTraceElement[]>`	`getAllStackTraces()` Returns a map of all the currently live threads to their stack traces.
`ClassLoader`	`getContextClassLoader()` Returns the context ClassLoader for this Thread.
`static Thread.UncaughtExceptionHandler`	`getDefaultUncaughtExceptionHandler()` Returns the default exception handler that's executed when uncaught exception terminates a thread.
`long`	`getId()` Returns the thread's identifier.
`String`	`getName()` Returns the name of the Thread.
`int`	`getPriority()` Returns the priority of the Thread.
`StackTraceElement[]`	`getStackTrace()` Returns an array of `StackTraceElement` representing the current thread's stack.
`Thread.State`	`getState()` Returns the current state of the Thread.
`ThreadGroup`	`getThreadGroup()` Returns the ThreadGroup to which this Thread belongs.
`Thread.UncaughtExceptionHandler`	`getUncaughtExceptionHandler()` Returns the thread's uncaught exception handler.
`static boolean`	`holdsLock(Object object)` Indicates whether the current Thread has a monitor lock on the specified object.
`void`	`interrupt()` Posts an interrupt request to this `Thread`.
`static boolean`	`interrupted()` Returns a `boolean` indicating whether the current Thread ( `currentThread()`) has a pending interrupt request (`true`) or not (`false`).
`boolean`	`isAlive()` Returns `true` if the receiver has already been started and still runs code (hasn't died yet).
`boolean`	`isDaemon()` Returns a `boolean` indicating whether the receiver is a daemon Thread (`true`) or not (`false`) A daemon Thread only runs as long as there are non-daemon Threads running.
`boolean`	`isInterrupted()` Returns a `boolean` indicating whether the receiver has a pending interrupt request (`true`) or not ( `false`)
`void`	`join()` Blocks the current Thread (`Thread.currentThread()`) until the receiver finishes its execution and dies.
`void`	`join(long millis)` Blocks the current Thread (`Thread.currentThread()`) until the receiver finishes its execution and dies or the specified timeout expires, whatever happens first.
`void`	`join(long millis, int nanos)` Blocks the current Thread (`Thread.currentThread()`) until the receiver finishes its execution and dies or the specified timeout expires, whatever happens first.
`void`	`parkFor(long nanos)` Parks the current thread for a particular number of nanoseconds, or indefinitely.
`void`	`parkUntil(long time)` Parks the current thread until the specified system time.
`void`	`popInterruptAction$(Runnable interruptAction)` Removes `interruptAction` so it is not invoked upon interruption.
`void`	`pushInterruptAction$(Runnable interruptAction)` Adds a runnable to be invoked upon interruption.
`void`	`resume()` Deprecated. Used with deprecated method `suspend()`
`void`	`run()` Calls the `run()` method of the Runnable object the receiver holds.
`void`	`setContextClassLoader(ClassLoader cl)` Set the context ClassLoader for the receiver.
`void`	`setDaemon(boolean isDaemon)` Set if the receiver is a daemon Thread or not.
`static void`	`setDefaultUncaughtExceptionHandler(Thread.UncaughtExceptionHandler handler)` Sets the default uncaught exception handler.
`void`	`setName(String threadName)` Sets the name of the Thread.
`void`	`setPriority(int priority)` Sets the priority of the Thread.
`void`	`setUncaughtExceptionHandler(Thread.UncaughtExceptionHandler handler)` Sets the uncaught exception handler.
`static void`	`sleep(long time)` Causes the thread which sent this message to sleep for the given interval of time (given in milliseconds).
`static void`	`sleep(long millis, int nanos)` Causes the thread which sent this message to sleep for the given interval of time (given in milliseconds and nanoseconds).
`void`	`start()` Starts the new Thread of execution.
`void`	`stop()` Deprecated. because stopping a thread in this manner is unsafe and can leave your application and the VM in an unpredictable state.
`void`	`stop(Throwable throwable)` Deprecated. because stopping a thread in this manner is unsafe and can leave your application and the VM in an unpredictable state.
`void`	`suspend()` Deprecated. May cause deadlocks.
`String`	`toString()` Returns a string containing a concise, human-readable description of the Thread.
`void`	`unpark()` Unparks this thread.
`static void`	`yield()` Causes the calling Thread to yield execution time to another Thread that is ready to run.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Field Detail
  - MAX_PRIORITY
```
public static final int MAX_PRIORITY
```
    The maximum priority value allowed for a thread.
    
    See Also:
    Constant Field Values
  - MIN_PRIORITY
```
public static final int MIN_PRIORITY
```
    The minimum priority value allowed for a thread.
    
    See Also:
    Constant Field Values
  - NORM_PRIORITY
```
public static final int NORM_PRIORITY
```
    The normal (default) priority value assigned to threads.
    
    See Also:
    Constant Field Values
- Constructor Detail
  - Thread
```
public Thread()
```
    Constructs a new Thread with no Runnable object and a newly generated name. The new Thread will belong to the same ThreadGroup as the Thread calling this constructor.
    
    See Also:
    ThreadGroup, Runnable
  - Thread
```
public Thread(Runnable runnable)
```
    Constructs a new Thread with a Runnable object and a newly generated name. The new Thread will belong to the same ThreadGroup as the Thread calling this constructor.
    
    Parameters:
    runnable - a Runnable whose method run will be executed by the new Thread
    See Also:
    ThreadGroup, Runnable
  - Thread
```
public Thread(Runnable runnable,
      String threadName)
```
    Constructs a new Thread with a Runnable object and name provided. The new Thread will belong to the same ThreadGroup as the Thread calling this constructor.
    
    Parameters:
    runnable - a Runnable whose method run will be executed by the new Thread
    threadName - the name for the Thread being created
    See Also:
    ThreadGroup, Runnable
  - Thread
```
public Thread(String threadName)
```
    Constructs a new Thread with no Runnable object and the name provided. The new Thread will belong to the same ThreadGroup as the Thread calling this constructor.
    
    Parameters:
    threadName - the name for the Thread being created
    See Also:
    ThreadGroup, Runnable
  - Thread
```
public Thread(ThreadGroup group,
      Runnable runnable)
```
    Constructs a new Thread with a Runnable object and a newly generated name. The new Thread will belong to the ThreadGroup passed as parameter.
    
    Parameters:
    group - ThreadGroup to which the new Thread will belong
    runnable - a Runnable whose method run will be executed by the new Thread
    
    Throws:
    
    IllegalThreadStateException - if group.destroy() has already been done
    See Also:
    ThreadGroup, Runnable
  - Thread
```
public Thread(ThreadGroup group,
      Runnable runnable,
      String threadName)
```
    Constructs a new Thread with a Runnable object, the given name and belonging to the ThreadGroup passed as parameter.
    
    Parameters:
    group - ThreadGroup to which the new Thread will belong
    runnable - a Runnable whose method run will be executed by the new Thread
    threadName - the name for the Thread being created
    
    Throws:
    
    IllegalThreadStateException - if group.destroy() has already been done
    See Also:
    ThreadGroup, Runnable
  - Thread
```
public Thread(ThreadGroup group,
      String threadName)
```
    Constructs a new Thread with no Runnable object, the given name and belonging to the ThreadGroup passed as parameter.
    
    Parameters:
    group - ThreadGroup to which the new Thread will belong
    threadName - the name for the Thread being created
    
    Throws:
    
    IllegalThreadStateException - if group.destroy() has already been done
    See Also:
    ThreadGroup, Runnable
  - Thread
```
public Thread(ThreadGroup group,
      Runnable runnable,
      String threadName,
      long stackSize)
```
    Constructs a new Thread with a Runnable object, the given name and belonging to the ThreadGroup passed as parameter.
    
    Parameters:
    group - ThreadGroup to which the new Thread will belong
    runnable - a Runnable whose method run will be executed by the new Thread
    threadName - the name for the Thread being created
    stackSize - a stack size for the new Thread. This has a highly platform-dependent interpretation. It may even be ignored completely.
    
    Throws:
    
    IllegalThreadStateException - if group.destroy() has already been done
    See Also:
    ThreadGroup, Runnable
- Method Detail
  - activeCount
```
public static int activeCount()
```
    Returns the number of active Threads in the running Thread's group and its subgroups.
    
    Returns:
    the number of Threads
  - checkAccess
```
public final void checkAccess()
```
    Does nothing.
  - countStackFrames
```
@Deprecated
public int countStackFrames()
```
    Deprecated. The results of this call were never well defined. To make things worse, it would depend on whether the Thread was suspended or not, and suspend was deprecated too.
    
    Returns the number of stack frames in this thread.
    
    Returns:
    Number of stack frames
  - currentThread
```
public static Thread currentThread()
```
    Returns the Thread of the caller, that is, the current Thread.
    
    Returns:
    the current Thread.
  - destroy
```
@Deprecated
public void destroy()
```
    Deprecated. Not implemented.
    
    Destroys the receiver without any monitor cleanup.
  - dumpStack
```
public static void dumpStack()
```
    Prints to the standard error stream a text representation of the current stack for this Thread.
    
    See Also:
    Throwable.printStackTrace()
  - enumerate
```
public static int enumerate(Thread[] threads)
```
    Copies an array with all Threads which are in the same ThreadGroup as the receiver - and subgroups - into the array threads passed as parameter. If the array passed as parameter is too small no exception is thrown - the extra elements are simply not copied.
    
    Parameters:
    threads - array into which the Threads will be copied
    
    Returns:
    How many Threads were copied over
  - getAllStackTraces
```
public static Map<Thread,StackTraceElement[]> getAllStackTraces()
```
    Returns a map of all the currently live threads to their stack traces.
  - getContextClassLoader
```
public ClassLoader getContextClassLoader()
```
    Returns the context ClassLoader for this Thread.
    
    Returns:
    ClassLoader The context ClassLoader
    See Also:
    ClassLoader, getContextClassLoader()
  - getDefaultUncaughtExceptionHandler
```
public static Thread.UncaughtExceptionHandler getDefaultUncaughtExceptionHandler()
```
    Returns the default exception handler that's executed when uncaught exception terminates a thread.
    
    Returns:
    an Thread.UncaughtExceptionHandler or null if none exists.
  - getId
```
public long getId()
```
    Returns the thread's identifier. The ID is a positive long generated on thread creation, is unique to the thread, and doesn't change during the lifetime of the thread; the ID may be reused after the thread has been terminated.
    
    Returns:
    the thread's ID.
  - getName
```
public final String getName()
```
    Returns the name of the Thread.
    
    Returns:
    the Thread's name
  - getPriority
```
public final int getPriority()
```
    Returns the priority of the Thread.
    
    Returns:
    the Thread's priority
    See Also:
    setPriority(int)
  - getStackTrace
```
public StackTraceElement[] getStackTrace()
```
    Returns an array of StackTraceElement representing the current thread's stack.
  - getState
```
public Thread.State getState()
```
    Returns the current state of the Thread. This method is useful for monitoring purposes.
    
    Returns:
    a Thread.State value.
  - getThreadGroup
```
public final ThreadGroup getThreadGroup()
```
    Returns the ThreadGroup to which this Thread belongs.
    
    Returns:
    the Thread's ThreadGroup
  - getUncaughtExceptionHandler
```
public Thread.UncaughtExceptionHandler getUncaughtExceptionHandler()
```
    Returns the thread's uncaught exception handler. If not explicitly set, then the ThreadGroup's handler is returned. If the thread is terminated, then null is returned.
    
    Returns:
    an Thread.UncaughtExceptionHandler instance or null.
  - interrupt
```
public void interrupt()
```
    Posts an interrupt request to this Thread. The behavior depends on the state of this Thread:
    - Threads blocked in one of Object's wait() methods or one of Thread's join() or sleep() methods will be woken up, their interrupt status will be cleared, and they receive an InterruptedException.
    - Threads blocked in an I/O operation of an InterruptibleChannel will have their interrupt status set and receive an ClosedByInterruptException. Also, the channel will be closed.
    - Threads blocked in a Selector will have their interrupt status set and return immediately. They don't receive an exception in this case.
    See Also:
    interrupted(), isInterrupted()
  - interrupted
```
public static boolean interrupted()
```
    Returns a boolean indicating whether the current Thread ( currentThread()) has a pending interrupt request (true) or not (false). It also has the side-effect of clearing the flag.
    
    Returns:
    a boolean indicating the interrupt status
    See Also:
    currentThread(), interrupt(), isInterrupted()
  - isAlive
```
public final boolean isAlive()
```
    Returns true if the receiver has already been started and still runs code (hasn't died yet). Returns false either if the receiver hasn't been started yet or if it has already started and run to completion and died.
    
    Returns:
    a boolean indicating the liveness of the Thread
    See Also:
    start()
  - isDaemon
```
public final boolean isDaemon()
```
    Returns a boolean indicating whether the receiver is a daemon Thread (true) or not (false) A daemon Thread only runs as long as there are non-daemon Threads running. When the last non-daemon Thread ends, the whole program ends no matter if it had daemon Threads still running or not.
    
    Returns:
    a boolean indicating whether the Thread is a daemon
    See Also:
    setDaemon(boolean)
  - isInterrupted
```
public boolean isInterrupted()
```
    Returns a boolean indicating whether the receiver has a pending interrupt request (true) or not ( false)
    
    Returns:
    a boolean indicating the interrupt status
    See Also:
    interrupt(), interrupted()
  - join
```
public final void join()
                throws InterruptedException
```
    Blocks the current Thread (Thread.currentThread()) until the receiver finishes its execution and dies.
    
    Throws:
    
    InterruptedException - if interrupt() was called for the receiver while it was in the join() call
    See Also:
    Object.notifyAll(), ThreadDeath
  - join
```
public final void join(long millis)
                throws InterruptedException
```
    Blocks the current Thread (Thread.currentThread()) until the receiver finishes its execution and dies or the specified timeout expires, whatever happens first.
    
    Parameters:
    millis - The maximum time to wait (in milliseconds).
    
    Throws:
    
    InterruptedException - if interrupt() was called for the receiver while it was in the join() call
    See Also:
    Object.notifyAll(), ThreadDeath
  - join
```
public final void join(long millis,
        int nanos)
                throws InterruptedException
```
    Blocks the current Thread (Thread.currentThread()) until the receiver finishes its execution and dies or the specified timeout expires, whatever happens first.
    
    Parameters:
    millis - The maximum time to wait (in milliseconds).
    nanos - Extra nanosecond precision
    
    Throws:
    
    InterruptedException - if interrupt() was called for the receiver while it was in the join() call
    See Also:
    Object.notifyAll(), ThreadDeath
  - resume
```
@Deprecated
public final void resume()
```
    Deprecated. Used with deprecated method suspend()
    
    Throws UnsupportedOperationException.
    
    See Also:
    suspend()
  - run
```
public void run()
```
    Calls the run() method of the Runnable object the receiver holds. If no Runnable is set, does nothing.
    
    Specified by:
    
    run in interface Runnable
    
    See Also:
    start()
  - setContextClassLoader
```
public void setContextClassLoader(ClassLoader cl)
```
    Set the context ClassLoader for the receiver.
    
    Parameters:
    cl - The context ClassLoader
    See Also:
    getContextClassLoader()
  - setDaemon
```
public final void setDaemon(boolean isDaemon)
```
    Set if the receiver is a daemon Thread or not. This can only be done before the Thread starts running.
    
    Parameters:
    isDaemon - indicates whether the Thread should be daemon or not
    See Also:
    isDaemon()
  - setDefaultUncaughtExceptionHandler
```
public static void setDefaultUncaughtExceptionHandler(Thread.UncaughtExceptionHandler handler)
```
    Sets the default uncaught exception handler. This handler is invoked in case any Thread dies due to an unhandled exception.
    
    Parameters:
    handler - The handler to set or null.
  - pushInterruptAction$
```
public final void pushInterruptAction$(Runnable interruptAction)
```
    Adds a runnable to be invoked upon interruption. If this thread has already been interrupted, the runnable will be invoked immediately. The action should be idempotent as it may be invoked multiple times for a single interruption.
    Each call to this method must be matched with a corresponding call to popInterruptAction$(java.lang.Runnable).
  - popInterruptAction$
```
public final void popInterruptAction$(Runnable interruptAction)
```
    Removes interruptAction so it is not invoked upon interruption.
    
    Parameters:
    interruptAction - the pushed action, used to check that the call stack is correctly nested.
  - setName
```
public final void setName(String threadName)
```
    Sets the name of the Thread.
    
    Parameters:
    threadName - the new name for the Thread
    See Also:
    getName()
  - setPriority
```
public final void setPriority(int priority)
```
    Sets the priority of the Thread. Note that the final priority set may not be the parameter that was passed - it will depend on the receiver's ThreadGroup. The priority cannot be set to be higher than the receiver's ThreadGroup's maxPriority().
    
    Parameters:
    priority - new priority for the Thread
    
    Throws:
    
    IllegalArgumentException - if the new priority is greater than Thread.MAX_PRIORITY or less than Thread.MIN_PRIORITY
    See Also:
    getPriority()
  - setUncaughtExceptionHandler
```
public void setUncaughtExceptionHandler(Thread.UncaughtExceptionHandler handler)
```
    Sets the uncaught exception handler. This handler is invoked in case this Thread dies due to an unhandled exception.
    
    Parameters:
    handler - The handler to set or null.
  - sleep
```
public static void sleep(long time)
                  throws InterruptedException
```
    Causes the thread which sent this message to sleep for the given interval of time (given in milliseconds). The precision is not guaranteed - the Thread may sleep more or less than requested.
    
    Parameters:
    time - The time to sleep in milliseconds.
    
    Throws:
    
    InterruptedException - if interrupt() was called for this Thread while it was sleeping
    See Also:
    interrupt()
  - sleep
```
public static void sleep(long millis,
         int nanos)
                  throws InterruptedException
```
    Causes the thread which sent this message to sleep for the given interval of time (given in milliseconds and nanoseconds). The precision is not guaranteed - the Thread may sleep more or less than requested.
    
    Parameters:
    millis - The time to sleep in milliseconds.
    nanos - Extra nanosecond precision
    
    Throws:
    
    InterruptedException - if interrupt() was called for this Thread while it was sleeping
    See Also:
    interrupt()
  - start
```
public void start()
```
    Starts the new Thread of execution. The run() method of the receiver will be called by the receiver Thread itself (and not the Thread calling start()).
    
    Throws:
    
    IllegalThreadStateException - if the Thread has been started before
    See Also:
    run()
  - stop
```
@Deprecated
public final void stop()
```
    Deprecated. because stopping a thread in this manner is unsafe and can leave your application and the VM in an unpredictable state.
    
    Requests the receiver Thread to stop and throw ThreadDeath. The Thread is resumed if it was suspended and awakened if it was sleeping, so that it can proceed to throw ThreadDeath.
  - stop
```
@Deprecated
public final void stop(Throwable throwable)
```
    Deprecated. because stopping a thread in this manner is unsafe and can leave your application and the VM in an unpredictable state.
    
    Throws UnsupportedOperationException.
    
    Throws:
    
    NullPointerException - if throwable() is null
  - suspend
```
@Deprecated
public final void suspend()
```
    Deprecated. May cause deadlocks.
    
    Throws UnsupportedOperationException.
    
    See Also:
    resume()
  - toString
```
public String toString()
```
    Returns a string containing a concise, human-readable description of the Thread. It includes the Thread's name, priority, and group name.
    
    Overrides:
    
    toString in class Object
    
    Returns:
    a printable representation for the receiver.
  - yield
```
public static void yield()
```
    Causes the calling Thread to yield execution time to another Thread that is ready to run. The actual scheduling is implementation-dependent.
  - holdsLock
```
public static boolean holdsLock(Object object)
```
    Indicates whether the current Thread has a monitor lock on the specified object.
    
    Parameters:
    object - the object to test for the monitor lock
    
    Returns:
    true if the current thread has a monitor lock on the specified object; false otherwise
  - unpark
```
public void unpark()
```
    Unparks this thread. This unblocks the thread it if it was previously parked, or indicates that the thread is "preemptively unparked" if it wasn't already parked. The latter means that the next time the thread is told to park, it will merely clear its latent park bit and carry on without blocking.
    See LockSupport for more in-depth information of the behavior of this method.
  - parkFor
```
public void parkFor(long nanos)
```
    Parks the current thread for a particular number of nanoseconds, or indefinitely. If not indefinitely, this method unparks the thread after the given number of nanoseconds if no other thread unparks it first. If the thread has been "preemptively unparked," this method cancels that unparking and returns immediately. This method may also return spuriously (that is, without the thread being told to unpark and without the indicated amount of time elapsing).
    See LockSupport for more in-depth information of the behavior of this method.
    
    This method must only be called when this is the current thread.
    
    Parameters:
    nanos - number of nanoseconds to park for or 0 to park indefinitely
    
    Throws:
    
    IllegalArgumentException - thrown if nanos < 0
  - parkUntil
```
public void parkUntil(long time)
```
    Parks the current thread until the specified system time. This method attempts to unpark the current thread immediately after System.currentTimeMillis() reaches the specified value, if no other thread unparks it first. If the thread has been "preemptively unparked," this method cancels that unparking and returns immediately. This method may also return spuriously (that is, without the thread being told to unpark and without the indicated amount of time elapsing).
    See LockSupport for more in-depth information of the behavior of this method.
    
    This method must only be called when this is the current thread.
    
    Parameters:
    time - the time after which the thread should be unparked, in absolute milliseconds-since-the-epoch

Content

Android Reference

A B C D E F G H I J K L M N O P Q R S T U V W X Y Z

Java basics

Java Enterprise Edition (EE)

Java Standard Edition (SE)

SQL

HTML

PHP

CSS

Java Script

MYSQL

JQUERY

VBS

REGEX

C

C++

C#

Design patterns

RFC (standard status)

RFC (proposed standard status)

RFC (draft standard status)

RFC (informational status)

RFC (experimental status)

RFC (best current practice status)

RFC (historic status)

RFC (unknown status)

IT dictionary

License.

All information of this service is derived from the free sources and is provided solely in the form of quotations. This service provides information and interfaces solely for the familiarization (not ownership) and under the "as is" condition.

IT. Expert System.

Android Reference

Thread

Class Thread

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

MAX_PRIORITY

MIN_PRIORITY

NORM_PRIORITY

Constructor Detail

Thread

Thread

Thread

Thread

Thread

Thread

Thread

Thread

Method Detail

activeCount

checkAccess

countStackFrames

currentThread

destroy

dumpStack

enumerate

getAllStackTraces

getContextClassLoader

getDefaultUncaughtExceptionHandler

getId

getName

getPriority

getStackTrace

getState

getThreadGroup

getUncaughtExceptionHandler

interrupt

interrupted

isAlive

isDaemon

isInterrupted

join

join

join

resume

run

setContextClassLoader

setDaemon

setDefaultUncaughtExceptionHandler

pushInterruptAction$

popInterruptAction$

setName

setPriority

setUncaughtExceptionHandler

sleep

sleep

start

stop

stop

suspend

toString

yield

holdsLock

unpark

parkFor

parkUntil

Android Reference

Java basics

Java Enterprise Edition (EE)

Java Standard Edition (SE)

SQL

HTML

PHP

CSS

Java Script

MYSQL