| Package | Description | 
|---|---|
| java.awt | Contains all of the classes for creating user
interfaces and for painting graphics and images. | 
| java.awt.event | Provides interfaces and classes for dealing with different
types of events fired by AWT components. | 
| java.awt.image.renderable | Provides classes and interfaces for producing
rendering-independent images. | 
| java.lang | Provides classes that are fundamental to the design of the Java
 programming language. | 
| java.util | Contains the collections framework, legacy collection classes, event model,
date and time facilities, internationalization, and miscellaneous utility
classes (a string tokenizer, a random-number generator, and a bit array). | 
| java.util.concurrent | Utility classes commonly useful in concurrent programming. | 
| java.util.stream | Classes to support functional-style operations on streams of elements, such
 as map-reduce transformations on collections. | 
| javax.net.ssl | Provides classes for the secure socket package. | 
| javax.swing | Provides a set of "lightweight"
(all-Java language) components that,
to the maximum degree possible, work the same on all platforms. | 
| javax.swing.text | Provides classes and interfaces that deal with editable
and noneditable text components. | 
| Modifier and Type | Method and Description | 
|---|---|
| static void | EventQueue. invokeAndWait(Runnable runnable) | 
| static void | EventQueue. invokeLater(Runnable runnable) | 
| Modifier and Type | Field and Description | 
|---|---|
| protected Runnable | InvocationEvent. runnableThe Runnable whose run() method will be called. | 
| Constructor and Description | 
|---|
| InvocationEvent(Object source,
               int id,
               Runnable runnable,
               Object notifier,
               boolean catchThrowables)Constructs an  InvocationEventwith the specified
 source and ID which will execute the runnable'srunmethod when dispatched. | 
| InvocationEvent(Object source,
               Runnable runnable)Constructs an  InvocationEventwith the specified
 source which will execute the runnable'srunmethod when dispatched. | 
| InvocationEvent(Object source,
               Runnable runnable,
               Object notifier,
               boolean catchThrowables)Constructs an  InvocationEventwith the specified
 source which will execute the runnable'srunmethod when dispatched. | 
| InvocationEvent(Object source,
               Runnable runnable,
               Runnable listener,
               boolean catchThrowables)Constructs an  InvocationEventwith the specified
 source which will execute the runnable'srunmethod when dispatched. | 
| Modifier and Type | Class and Description | 
|---|---|
| class  | RenderableImageProducerAn adapter class that implements ImageProducer to allow the
 asynchronous production of a RenderableImage. | 
| Modifier and Type | Class and Description | 
|---|---|
| class  | ThreadA thread is a thread of execution in a program. | 
| Constructor and Description | 
|---|
| Thread(Runnable target)Allocates a new  Threadobject. | 
| Thread(Runnable target,
      String name)Allocates a new  Threadobject. | 
| Thread(ThreadGroup group,
      Runnable target)Allocates a new  Threadobject. | 
| Thread(ThreadGroup group,
      Runnable target,
      String name)Allocates a new  Threadobject so that it hastargetas its run object, has the specifiednameas its name,
 and belongs to the thread group referred to bygroup. | 
| Thread(ThreadGroup group,
      Runnable target,
      String name,
      long stackSize)Allocates a new  Threadobject so that it hastargetas its run object, has the specifiednameas its name,
 and belongs to the thread group referred to bygroup, and has
 the specified stack size. | 
| Modifier and Type | Class and Description | 
|---|---|
| class  | TimerTaskA task that can be scheduled for one-time or repeated execution by a Timer. | 
| Modifier and Type | Interface and Description | 
|---|---|
| interface  | RunnableFuture<V> | 
| interface  | RunnableScheduledFuture<V>A  ScheduledFuturethat isRunnable. | 
| Modifier and Type | Class and Description | 
|---|---|
| class  | ForkJoinWorkerThreadA thread managed by a  ForkJoinPool, which executesForkJoinTasks. | 
| class  | FutureTask<V>A cancellable asynchronous computation. | 
| Modifier and Type | Method and Description | 
|---|---|
| BlockingQueue<Runnable> | ThreadPoolExecutor. getQueue()Returns the task queue used by this executor. | 
| BlockingQueue<Runnable> | ScheduledThreadPoolExecutor. getQueue()Returns the task queue used by this executor. | 
| List<Runnable> | ThreadPoolExecutor. shutdownNow()Attempts to stop all actively executing tasks, halts the
 processing of waiting tasks, and returns a list of the tasks
 that were awaiting execution. | 
| List<Runnable> | ForkJoinPool. shutdownNow()Possibly attempts to cancel and/or stop all tasks, and reject
 all subsequently submitted tasks. | 
| List<Runnable> | ExecutorService. shutdownNow()Attempts to stop all actively executing tasks, halts the
 processing of waiting tasks, and returns a list of the tasks
 that were awaiting execution. | 
| List<Runnable> | ScheduledThreadPoolExecutor. shutdownNow()Attempts to stop all actively executing tasks, halts the
 processing of waiting tasks, and returns a list of the tasks
 that were awaiting execution. | 
| Modifier and Type | Method and Description | 
|---|---|
| static ForkJoinTask<?> | ForkJoinTask. adapt(Runnable runnable)Returns a new  ForkJoinTaskthat performs therunmethod of the givenRunnableas its action, and returns
 a null result uponForkJoinTask.join(). | 
| static <T> ForkJoinTask<T> | ForkJoinTask. adapt(Runnable runnable,
     T result)Returns a new  ForkJoinTaskthat performs therunmethod of the givenRunnableas its action, and returns
 the given result uponForkJoinTask.join(). | 
| protected void | ThreadPoolExecutor. afterExecute(Runnable r,
            Throwable t)Method invoked upon completion of execution of the given Runnable. | 
| protected void | ThreadPoolExecutor. beforeExecute(Thread t,
             Runnable r)Method invoked prior to executing the given Runnable in the
 given thread. | 
| static Callable<Object> | Executors. callable(Runnable task)Returns a  Callableobject that, when
 called, runs the given task and returnsnull. | 
| static <T> Callable<T> | Executors. callable(Runnable task,
        T result)Returns a  Callableobject that, when
 called, runs the given task and returns the given result. | 
| protected <V> RunnableScheduledFuture<V> | ScheduledThreadPoolExecutor. decorateTask(Runnable runnable,
            RunnableScheduledFuture<V> task)Modifies or replaces the task used to execute a runnable. | 
| void | Executor. execute(Runnable command)Executes the given command at some time in the future. | 
| void | ThreadPoolExecutor. execute(Runnable command)Executes the given task sometime in the future. | 
| void | ForkJoinPool. execute(Runnable task) | 
| void | ScheduledThreadPoolExecutor. execute(Runnable command)Executes  commandwith zero required delay. | 
| protected <T> RunnableFuture<T> | AbstractExecutorService. newTaskFor(Runnable runnable,
          T value)Returns a  RunnableFuturefor the given runnable and default
 value. | 
| protected <T> RunnableFuture<T> | ForkJoinPool. newTaskFor(Runnable runnable,
          T value) | 
| Thread | ThreadFactory. newThread(Runnable r)Constructs a new  Thread. | 
| void | RejectedExecutionHandler. rejectedExecution(Runnable r,
                 ThreadPoolExecutor executor)Method that may be invoked by a  ThreadPoolExecutorwhenexecutecannot accept a
 task. | 
| void | ThreadPoolExecutor.CallerRunsPolicy. rejectedExecution(Runnable r,
                 ThreadPoolExecutor e)Executes task r in the caller's thread, unless the executor
 has been shut down, in which case the task is discarded. | 
| void | ThreadPoolExecutor.AbortPolicy. rejectedExecution(Runnable r,
                 ThreadPoolExecutor e)Always throws RejectedExecutionException. | 
| void | ThreadPoolExecutor.DiscardPolicy. rejectedExecution(Runnable r,
                 ThreadPoolExecutor e)Does nothing, which has the effect of discarding task r. | 
| void | ThreadPoolExecutor.DiscardOldestPolicy. rejectedExecution(Runnable r,
                 ThreadPoolExecutor e)Obtains and ignores the next task that the executor
 would otherwise execute, if one is immediately available,
 and then retries execution of task r, unless the executor
 is shut down, in which case task r is instead discarded. | 
| boolean | ThreadPoolExecutor. remove(Runnable task)Removes this task from the executor's internal queue if it is
 present, thus causing it not to be run if it has not already
 started. | 
| CompletableFuture<Void> | CompletableFuture. runAfterBoth(CompletionStage<?> other,
            Runnable action) | 
| CompletionStage<Void> | CompletionStage. runAfterBoth(CompletionStage<?> other,
            Runnable action)Returns a new CompletionStage that, when this and the other
 given stage both complete normally, executes the given action. | 
| CompletableFuture<Void> | CompletableFuture. runAfterBothAsync(CompletionStage<?> other,
                 Runnable action) | 
| CompletionStage<Void> | CompletionStage. runAfterBothAsync(CompletionStage<?> other,
                 Runnable action)Returns a new CompletionStage that, when this and the other
 given stage complete normally, executes the given action using
 this stage's default asynchronous execution facility. | 
| CompletableFuture<Void> | CompletableFuture. runAfterBothAsync(CompletionStage<?> other,
                 Runnable action,
                 Executor executor) | 
| CompletionStage<Void> | CompletionStage. runAfterBothAsync(CompletionStage<?> other,
                 Runnable action,
                 Executor executor)Returns a new CompletionStage that, when this and the other
 given stage complete normally, executes the given action using
 the supplied executor. | 
| CompletableFuture<Void> | CompletableFuture. runAfterEither(CompletionStage<?> other,
              Runnable action) | 
| CompletionStage<Void> | CompletionStage. runAfterEither(CompletionStage<?> other,
              Runnable action)Returns a new CompletionStage that, when either this or the
 other given stage complete normally, executes the given action. | 
| CompletableFuture<Void> | CompletableFuture. runAfterEitherAsync(CompletionStage<?> other,
                   Runnable action) | 
| CompletionStage<Void> | CompletionStage. runAfterEitherAsync(CompletionStage<?> other,
                   Runnable action)Returns a new CompletionStage that, when either this or the
 other given stage complete normally, executes the given action
 using this stage's default asynchronous execution facility. | 
| CompletableFuture<Void> | CompletableFuture. runAfterEitherAsync(CompletionStage<?> other,
                   Runnable action,
                   Executor executor) | 
| CompletionStage<Void> | CompletionStage. runAfterEitherAsync(CompletionStage<?> other,
                   Runnable action,
                   Executor executor)Returns a new CompletionStage that, when either this or the
 other given stage complete normally, executes the given action
 using the supplied executor. | 
| static CompletableFuture<Void> | CompletableFuture. runAsync(Runnable runnable)Returns a new CompletableFuture that is asynchronously completed
 by a task running in the  ForkJoinPool.commonPool()after
 it runs the given action. | 
| static CompletableFuture<Void> | CompletableFuture. runAsync(Runnable runnable,
        Executor executor)Returns a new CompletableFuture that is asynchronously completed
 by a task running in the given executor after it runs the given
 action. | 
| ScheduledFuture<?> | ScheduledExecutorService. schedule(Runnable command,
        long delay,
        TimeUnit unit)Creates and executes a one-shot action that becomes enabled
 after the given delay. | 
| ScheduledFuture<?> | ScheduledThreadPoolExecutor. schedule(Runnable command,
        long delay,
        TimeUnit unit) | 
| ScheduledFuture<?> | ScheduledExecutorService. scheduleAtFixedRate(Runnable command,
                   long initialDelay,
                   long period,
                   TimeUnit unit)Creates and executes a periodic action that becomes enabled first
 after the given initial delay, and subsequently with the given
 period; that is executions will commence after
  initialDelaytheninitialDelay+period, theninitialDelay + 2 * period, and so on. | 
| ScheduledFuture<?> | ScheduledThreadPoolExecutor. scheduleAtFixedRate(Runnable command,
                   long initialDelay,
                   long period,
                   TimeUnit unit) | 
| ScheduledFuture<?> | ScheduledExecutorService. scheduleWithFixedDelay(Runnable command,
                      long initialDelay,
                      long delay,
                      TimeUnit unit)Creates and executes a periodic action that becomes enabled first
 after the given initial delay, and subsequently with the
 given delay between the termination of one execution and the
 commencement of the next. | 
| ScheduledFuture<?> | ScheduledThreadPoolExecutor. scheduleWithFixedDelay(Runnable command,
                      long initialDelay,
                      long delay,
                      TimeUnit unit) | 
| Future<?> | AbstractExecutorService. submit(Runnable task) | 
| ForkJoinTask<?> | ForkJoinPool. submit(Runnable task) | 
| Future<?> | ExecutorService. submit(Runnable task)Submits a Runnable task for execution and returns a Future
 representing that task. | 
| Future<?> | ScheduledThreadPoolExecutor. submit(Runnable task) | 
| <T> Future<T> | AbstractExecutorService. submit(Runnable task,
      T result) | 
| <T> ForkJoinTask<T> | ForkJoinPool. submit(Runnable task,
      T result) | 
| <T> Future<T> | ExecutorService. submit(Runnable task,
      T result)Submits a Runnable task for execution and returns a Future
 representing that task. | 
| <T> Future<T> | ScheduledThreadPoolExecutor. submit(Runnable task,
      T result) | 
| Future<V> | CompletionService. submit(Runnable task,
      V result)Submits a Runnable task for execution and returns a Future
 representing that task. | 
| Future<V> | ExecutorCompletionService. submit(Runnable task,
      V result) | 
| CompletableFuture<Void> | CompletableFuture. thenRun(Runnable action) | 
| CompletionStage<Void> | CompletionStage. thenRun(Runnable action)Returns a new CompletionStage that, when this stage completes
 normally, executes the given action. | 
| CompletableFuture<Void> | CompletableFuture. thenRunAsync(Runnable action) | 
| CompletionStage<Void> | CompletionStage. thenRunAsync(Runnable action)Returns a new CompletionStage that, when this stage completes
 normally, executes the given action using this stage's default
 asynchronous execution facility. | 
| CompletableFuture<Void> | CompletableFuture. thenRunAsync(Runnable action,
            Executor executor) | 
| CompletionStage<Void> | CompletionStage. thenRunAsync(Runnable action,
            Executor executor)Returns a new CompletionStage that, when this stage completes
 normally, executes the given action using the supplied Executor. | 
| Constructor and Description | 
|---|
| CyclicBarrier(int parties,
             Runnable barrierAction)Creates a new  CyclicBarrierthat will trip when the
 given number of parties (threads) are waiting upon it, and which
 will execute the given barrier action when the barrier is tripped,
 performed by the last thread entering the barrier. | 
| FutureTask(Runnable runnable,
          V result)Creates a  FutureTaskthat will, upon running, execute the
 givenRunnable, and arrange thatgetwill return the
 given result on successful completion. | 
| Constructor and Description | 
|---|
| ThreadPoolExecutor(int corePoolSize,
                  int maximumPoolSize,
                  long keepAliveTime,
                  TimeUnit unit,
                  BlockingQueue<Runnable> workQueue)Creates a new  ThreadPoolExecutorwith the given initial
 parameters and default thread factory and rejected execution handler. | 
| ThreadPoolExecutor(int corePoolSize,
                  int maximumPoolSize,
                  long keepAliveTime,
                  TimeUnit unit,
                  BlockingQueue<Runnable> workQueue,
                  RejectedExecutionHandler handler)Creates a new  ThreadPoolExecutorwith the given initial
 parameters and default thread factory. | 
| ThreadPoolExecutor(int corePoolSize,
                  int maximumPoolSize,
                  long keepAliveTime,
                  TimeUnit unit,
                  BlockingQueue<Runnable> workQueue,
                  ThreadFactory threadFactory)Creates a new  ThreadPoolExecutorwith the given initial
 parameters and default rejected execution handler. | 
| ThreadPoolExecutor(int corePoolSize,
                  int maximumPoolSize,
                  long keepAliveTime,
                  TimeUnit unit,
                  BlockingQueue<Runnable> workQueue,
                  ThreadFactory threadFactory,
                  RejectedExecutionHandler handler)Creates a new  ThreadPoolExecutorwith the given initial
 parameters. | 
| Modifier and Type | Method and Description | 
|---|---|
| S | BaseStream. onClose(Runnable closeHandler)Returns an equivalent stream with an additional close handler. | 
| Modifier and Type | Method and Description | 
|---|---|
| abstract Runnable | SSLEngine. getDelegatedTask()Returns a delegated  Runnabletask for
 thisSSLEngine. | 
| Modifier and Type | Class and Description | 
|---|---|
| class  | SwingWorker<T,V>An abstract class to perform lengthy GUI-interaction tasks in a
 background thread. | 
| Modifier and Type | Method and Description | 
|---|---|
| static void | SwingUtilities. invokeAndWait(Runnable doRun)Causes  doRun.run()to be executed synchronously on the
 AWT event dispatching thread. | 
| static void | SwingUtilities. invokeLater(Runnable doRun)Causes doRun.run() to be executed asynchronously on the
 AWT event dispatching thread. | 
| Modifier and Type | Class and Description | 
|---|---|
| class  | AsyncBoxView.ChildStateA record representing the layout state of a
 child view. | 
| Modifier and Type | Method and Description | 
|---|---|
| protected Runnable | LayoutQueue. waitForWork()Used by the worker thread to get a new task to execute | 
| Modifier and Type | Method and Description | 
|---|---|
| void | LayoutQueue. addTask(Runnable task)Add a task that is not needed immediately because
 the results are not believed to be visible. | 
| void | AbstractDocument. render(Runnable r)This allows the model to be safely rendered in the presence
 of currency, if the model supports being updated asynchronously. | 
| void | Document. render(Runnable r)Allows the model to be safely rendered in the presence
 of concurrency, if the model supports being updated asynchronously. | 
 Submit a bug or feature 
For further API reference and developer documentation, see Java SE Documentation. That documentation contains more detailed, developer-targeted descriptions, with conceptual overviews, definitions of terms, workarounds, and working code examples.
 Copyright © 1993, 2017, Oracle and/or its affiliates.  All rights reserved. Use is subject to license terms. Also see the documentation redistribution policy.