Package java.lang

Class Thread

  • All Implemented Interfaces:
    Runnable
    Direct Known Subclasses:
    DeleteOnExit, ForkJoinWorkerThread
    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 application has at least one thread running when it is started, the main thread, in the main ThreadGroup. The runtime keeps its own threads in the system thread group.

    There are two ways to execute code in a new thread. You can either subclass Thread and overriding its run() method, or construct a new Thread and pass a Runnable to the constructor. In either case, the start() method must be called to actually execute the new Thread.

    Each Thread has an integer priority that affect how the thread is scheduled by the OS. A new thread inherits the priority of its parent. A thread's priority can be set using the setPriority(int) method.

    • Nested Class Summary

      Nested Classes 
      Modifier and Type Class 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 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 the main thread.

    • Constructor Summary

      Constructors 
      Constructor 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

      All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods 
      Modifier and Type Method Description
      static int activeCount()
      Returns the number of active Threads 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.
      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()
      Tests whether this is a daemon thread.
      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.
      Only useful in conjunction 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)
      Marks this thread as a daemon thread.
      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 this 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.

    • Field Detail

      • MAX_PRIORITY

        public static final int MAX_PRIORITY
        The maximum priority value allowed for a thread. This corresponds to (but does not have the same value as) android.os.Process.THREAD_PRIORITY_URGENT_DISPLAY.
        See Also:
        Constant Field Values

      • MIN_PRIORITY

        public static final int MIN_PRIORITY
        The minimum priority value allowed for a thread. This corresponds to (but does not have the same value as) android.os.Process.THREAD_PRIORITY_LOWEST.
        See Also:
        Constant Field Values

      • NORM_PRIORITY

        public static final int NORM_PRIORITY
        The normal (default) priority value assigned to the main thread. This corresponds to (but does not have the same value as) android.os.Process.THREAD_PRIORITY_DEFAULT.
        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.

      • destroy

        @Deprecated
public void destroy()
        Deprecated.
        Not implemented.
        Throws UnsupportedOperationException.

      • 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.

      • 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.

      • getPriority

        public final int getPriority()
        Returns the priority of the Thread.

      • 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()
          Tests whether this is a daemon thread. A daemon thread only runs as long as there are non-daemon threads running. When the last non-daemon thread ends, the runtime will exit. This is not normally relevant to applications with a UI.

        • 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 the current thread has been interrupted. The interrupted status of the current thread will be cleared before the exception is thrown.
          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.

          A timeout of zero means the calling thread should wait forever unless interrupted.

          Parameters:
          millis - The maximum time to wait (in milliseconds).
          Throws:
          InterruptedException - if the current thread has been interrupted. The interrupted status of the current thread will be cleared before the exception is thrown.
          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.

          A timeout of zero means the calling thread should wait forever unless interrupted.

          Parameters:
          millis - The maximum time to wait (in milliseconds).
          nanos - Extra nanosecond precision
          Throws:
          InterruptedException - if the current thread has been interrupted. The interrupted status of the current thread will be cleared before the exception is thrown.
          See Also:
          Object.notifyAll(), ThreadDeath

        • resume

          @Deprecated
public final void resume()
          Deprecated.
          Only useful in conjunction with deprecated method suspend().
          Throws UnsupportedOperationException.

        • 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)
          Marks this thread as a daemon thread. A daemon thread only runs as long as there are non-daemon threads running. When the last non-daemon thread ends, the runtime will exit. This is not normally relevant to applications with a UI.
          Throws:
          IllegalThreadStateException - - if this thread has already started.

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

        • 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 the current thread has been interrupted. The interrupted status of the current thread will be cleared before the exception is thrown.
          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 the current thread has been interrupted. The interrupted status of the current thread will be cleared before the exception is thrown.
          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 this thread has already started.
          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.

        • suspend

          @Deprecated
public final void suspend()
          Deprecated.
          May cause deadlocks.
          Throws UnsupportedOperationException.

        • 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 final 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 final 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 final 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