|
Préférences
Moteurs de recherche
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||
JavaTM 2 Platform Std. Ed. v1.5.0
java.util.concurrent
|
Nested Class Summary |
---|
Nested classes/interfaces inherited from class java.util.concurrent.ThreadPoolExecutor |
---|
ThreadPoolExecutor.AbortPolicy, ThreadPoolExecutor.CallerRunsPolicy, ThreadPoolExecutor.DiscardOldestPolicy, ThreadPoolExecutor.DiscardPolicy |
Constructor Summary | |
---|---|
ScheduledThreadPoolExecutor(int corePoolSize)
Creates a new ScheduledThreadPoolExecutor with the given core pool size. |
|
ScheduledThreadPoolExecutor(int corePoolSize,
RejectedExecutionHandler handler)
Creates a new ScheduledThreadPoolExecutor with the given initial parameters. |
|
ScheduledThreadPoolExecutor(int corePoolSize,
ThreadFactory threadFactory)
Creates a new ScheduledThreadPoolExecutor with the given initial parameters. |
|
ScheduledThreadPoolExecutor(int corePoolSize,
ThreadFactory threadFactory,
RejectedExecutionHandler handler)
Creates a new ScheduledThreadPoolExecutor with the given initial parameters. |
Method Summary | ||
---|---|---|
void |
execute(Runnable command)
Execute command with zero required delay. |
|
boolean |
getContinueExistingPeriodicTasksAfterShutdownPolicy()
Get the policy on whether to continue executing existing periodic tasks even when this executor has been shutdown. |
|
boolean |
getExecuteExistingDelayedTasksAfterShutdownPolicy()
Get policy on whether to execute existing delayed tasks even when this executor has been shutdown. |
|
BlockingQueue<Runnable> |
getQueue()
Returns the task queue used by this executor. |
|
boolean |
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. |
|
|
schedule(Callable<V> callable,
long delay,
TimeUnit unit)
Creates and executes a ScheduledFuture that becomes enabled after the given delay. |
|
ScheduledFuture<?> |
schedule(Runnable command,
long delay,
TimeUnit unit)
Creates and executes a one-shot action that becomes enabled after the given delay. |
|
ScheduledFuture<?> |
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 initialDelay then initialDelay+period, then initialDelay + 2 * period, and so on. |
|
ScheduledFuture<?> |
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. |
|
void |
setContinueExistingPeriodicTasksAfterShutdownPolicy(boolean value)
Set policy on whether to continue executing existing periodic tasks even when this executor has been shutdown. |
|
void |
setExecuteExistingDelayedTasksAfterShutdownPolicy(boolean value)
Set policy on whether to execute existing delayed tasks even when this executor has been shutdown. |
|
void |
shutdown()
Initiates an orderly shutdown in which previously submitted tasks are executed, but no new tasks will be accepted. |
|
List<Runnable> |
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. |
|
|
submit(Callable<T> task)
Submits a value-returning task for execution and returns a Future representing the pending results of the task. |
|
Future<?> |
submit(Runnable task)
Submits a Runnable task for execution and returns a Future representing that task. |
|
|
submit(Runnable task,
T result)
Submits a Runnable task for execution and returns a Future representing that task that will upon completion return the given result |
Methods inherited from class java.util.concurrent.AbstractExecutorService |
---|
invokeAll, invokeAll, invokeAny, invokeAny |
Methods inherited from class java.lang.Object |
---|
clone, equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
Methods inherited from interface java.util.concurrent.ExecutorService |
---|
awaitTermination, invokeAll, invokeAll, invokeAny, invokeAny, isShutdown, isTerminated |
Constructor Detail |
---|
public ScheduledThreadPoolExecutor(int corePoolSize)
corePoolSize
- the number of threads to keep in the pool,
even if they are idle.
IllegalArgumentException
- if corePoolSize less than or
equal to zeropublic ScheduledThreadPoolExecutor(int corePoolSize, ThreadFactory threadFactory)
corePoolSize
- the number of threads to keep in the pool,
even if they are idle.threadFactory
- the factory to use when the executor
creates a new thread.
NullPointerException
- if threadFactory is nullpublic ScheduledThreadPoolExecutor(int corePoolSize, RejectedExecutionHandler handler)
corePoolSize
- the number of threads to keep in the pool,
even if they are idle.handler
- the handler to use when execution is blocked
because the thread bounds and queue capacities are reached.
NullPointerException
- if handler is nullpublic ScheduledThreadPoolExecutor(int corePoolSize, ThreadFactory threadFactory, RejectedExecutionHandler handler)
corePoolSize
- the number of threads to keep in the pool,
even if they are idle.threadFactory
- the factory to use when the executor
creates a new thread.handler
- the handler to use when execution is blocked
because the thread bounds and queue capacities are reached.
NullPointerException
- if threadFactory or handler is nullMethod Detail |
---|
public boolean remove(Runnable task)
ThreadPoolExecutor
This method may be useful as one part of a cancellation
scheme. It may fail to remove tasks that have been converted
into other forms before being placed on the internal queue. For
example, a task entered using submit might be
converted into a form that maintains Future status.
However, in such cases, method ThreadPoolExecutor.purge()
may be used to remove those Futures that have been cancelled.
remove
in class ThreadPoolExecutor
task
- the task to remove
public ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit)
ScheduledExecutorService
schedule
in interface ScheduledExecutorService
command
- the task to execute.delay
- the time from now to delay execution.unit
- the time unit of the delay parameter.
public <V> ScheduledFuture<V> schedule(Callable<V> callable, long delay, TimeUnit unit)
ScheduledExecutorService
schedule
in interface ScheduledExecutorService
callable
- the function to execute.delay
- the time from now to delay execution.unit
- the time unit of the delay parameter.
public ScheduledFuture<?> scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit)
ScheduledExecutorService
scheduleAtFixedRate
in interface ScheduledExecutorService
command
- the task to execute.initialDelay
- the time to delay first execution.period
- the period between successive executions.unit
- the time unit of the initialDelay and period parameters
public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit)
ScheduledExecutorService
scheduleWithFixedDelay
in interface ScheduledExecutorService
command
- the task to execute.initialDelay
- the time to delay first execution.delay
- the delay between the termination of one
execution and the commencement of the next.unit
- the time unit of the initialDelay and delay parameters
public void execute(Runnable command)
ScheduledFuture
, not the command itself.
execute
in interface Executor
execute
in class ThreadPoolExecutor
command
- the task to execute
RejectedExecutionException
- at discretion of
RejectedExecutionHandler, if task cannot be accepted
for execution because the executor has been shut down.
NullPointerException
- if command is nullpublic Future<?> submit(Runnable task)
ExecutorService
submit
in interface ExecutorService
submit
in class AbstractExecutorService
task
- the task to submit
public <T> Future<T> submit(Runnable task, T result)
ExecutorService
submit
in interface ExecutorService
submit
in class AbstractExecutorService
task
- the task to submitresult
- the result to return
public <T> Future<T> submit(Callable<T> task)
ExecutorService
If you would like to immediately block waiting for a task, you can use constructions of the form result = exec.submit(aCallable).get();
Note: The Executors
class includes a set of methods
that can convert some other common closure-like objects,
for example, PrivilegedAction
to
Callable
form so they can be submitted.
submit
in interface ExecutorService
submit
in class AbstractExecutorService
task
- the task to submit
public void setContinueExistingPeriodicTasksAfterShutdownPolicy(boolean value)
value
- if true, continue after shutdown, else don't.getExecuteExistingDelayedTasksAfterShutdownPolicy()
public boolean getContinueExistingPeriodicTasksAfterShutdownPolicy()
setContinueExistingPeriodicTasksAfterShutdownPolicy(boolean)
public void setExecuteExistingDelayedTasksAfterShutdownPolicy(boolean value)
value
- if true, execute after shutdown, else don't.getExecuteExistingDelayedTasksAfterShutdownPolicy()
public boolean getExecuteExistingDelayedTasksAfterShutdownPolicy()
setExecuteExistingDelayedTasksAfterShutdownPolicy(boolean)
public void shutdown()
shutdown
in interface ExecutorService
shutdown
in class ThreadPoolExecutor
public List<Runnable> shutdownNow()
There are no guarantees beyond best-effort attempts to stop
processing actively executing tasks. This implementation
cancels tasks via Thread.interrupt()
, so if any tasks mask or
fail to respond to interrupts, they may never terminate.
shutdownNow
in interface ExecutorService
shutdownNow
in class ThreadPoolExecutor
ScheduledFuture
,
including those tasks submitted using execute, which
are for scheduling purposes used as the basis of a zero-delay
ScheduledFuture.public BlockingQueue<Runnable> getQueue()
ScheduledFuture
, including those
tasks submitted using execute which are for scheduling
purposes used as the basis of a zero-delay
ScheduledFuture. Iteration over this queue is
not guaranteed to traverse tasks in the order in
which they will execute.
getQueue
in class ThreadPoolExecutor