|
Préférences
Moteurs de recherche
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
JavaTM 2 Platform Std. Ed. v1.6.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 | ||
---|---|---|
protected
|
decorateTask(Callable<V> callable,
RunnableScheduledFuture<V> task)
Modifies or replaces the task used to execute a callable. |
|
protected
|
decorateTask(Runnable runnable,
RunnableScheduledFuture<V> task)
Modifies or replaces the task used to execute a runnable. |
|
void |
execute(Runnable command)
Executes command with zero required delay. |
|
boolean |
getContinueExistingPeriodicTasksAfterShutdownPolicy()
Gets the policy on whether to continue executing existing periodic tasks even when this executor has been shutdown. |
|
boolean |
getExecuteExistingDelayedTasksAfterShutdownPolicy()
Gets the 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)
Sets the policy on whether to continue executing existing periodic tasks even when this executor has been shutdown. |
|
void |
setExecuteExistingDelayedTasksAfterShutdownPolicy(boolean value)
Sets the 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. |
Methods inherited from class java.util.concurrent.AbstractExecutorService |
---|
invokeAll, invokeAll, invokeAny, invokeAny, newTaskFor, newTaskFor |
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 < 0public ScheduledThreadPoolExecutor(int corePoolSize, ThreadFactory threadFactory)
corePoolSize
- the number of threads to keep in the pool,
even if they are idlethreadFactory
- the factory to use when the executor
creates a new thread
IllegalArgumentException
- if corePoolSize < 0
NullPointerException
- if threadFactory is nullpublic ScheduledThreadPoolExecutor(int corePoolSize, RejectedExecutionHandler handler)
corePoolSize
- the number of threads to keep in the pool,
even if they are idlehandler
- the handler to use when execution is blocked
because the thread bounds and queue capacities are reached
IllegalArgumentException
- if corePoolSize < 0
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 idlethreadFactory
- the factory to use when the executor
creates a new threadhandler
- the handler to use when execution is blocked
because the thread bounds and queue capacities are reached.
IllegalArgumentException
- if corePoolSize < 0
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
protected <V> RunnableScheduledFuture<V> decorateTask(Runnable runnable, RunnableScheduledFuture<V> task)
runnable
- the submitted Runnabletask
- the task created to execute the runnable
protected <V> RunnableScheduledFuture<V> decorateTask(Callable<V> callable, RunnableScheduledFuture<V> task)
callable
- the submitted Callabletask
- the task created to execute the callable
public ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit)
ScheduledExecutorService
schedule
in interface ScheduledExecutorService
command
- the task to executedelay
- the time from now to delay executionunit
- 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 executedelay
- the time from now to delay executionunit
- 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 executeinitialDelay
- the time to delay first executionperiod
- the period between successive executionsunit
- 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 executeinitialDelay
- the time to delay first executiondelay
- the delay between the termination of one
execution and the commencement of the nextunit
- 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.getContinueExistingPeriodicTasksAfterShutdownPolicy()
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 any task that
fails to respond to interrupts 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.
SecurityException
- if a security manager exists and
shutting down this ExecutorService may manipulate threads that
the caller is not permitted to modify because it does not hold
RuntimePermission
("modifyThread"),
or the security manager's checkAccess method denies access.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