sample/java.util.concurrent.ScheduledThreadPoolExecutor.txt

   1 *java.util.concurrent.ScheduledThreadPoolExecutor* *ScheduledThreadPoolExecutor*
   2
   3 public class ScheduledThreadPoolExecutor
   4   extends    |java.util.concurrent.ThreadPoolExecutor|
   5   implements |java.util.concurrent.ScheduledExecutorService|
   6
   7 |java.util.concurrent.ScheduledThreadPoolExecutor_Description|
   8 |java.util.concurrent.ScheduledThreadPoolExecutor_Fields|
   9 |java.util.concurrent.ScheduledThreadPoolExecutor_Constructors|
  10 |java.util.concurrent.ScheduledThreadPoolExecutor_Methods|
  11
  12 ================================================================================
  13
  14 *java.util.concurrent.ScheduledThreadPoolExecutor_Constructors*
  15 |java.util.concurrent.ScheduledThreadPoolExecutor(int)|Creates a new ScheduledT
  16 |java.util.concurrent.ScheduledThreadPoolExecutor(int,RejectedExecutionHandler)|
  17 |java.util.concurrent.ScheduledThreadPoolExecutor(int,ThreadFactory)|Creates a
  18 |java.util.concurrent.ScheduledThreadPoolExecutor(int,ThreadFactory,RejectedExecutionHandler)|
  19
  20 *java.util.concurrent.ScheduledThreadPoolExecutor_Methods*
  21 |java.util.concurrent.ScheduledThreadPoolExecutor.decorateTask(Callable<V>,RunnableScheduledFuture<V>)|
  22 |java.util.concurrent.ScheduledThreadPoolExecutor.decorateTask(Runnable,RunnableScheduledFuture<V>)|
  23 |java.util.concurrent.ScheduledThreadPoolExecutor.execute(Runnable)|Executes co
  24 |java.util.concurrent.ScheduledThreadPoolExecutor.getContinueExistingPeriodicTasksAfterShutdownPolicy()|
  25 |java.util.concurrent.ScheduledThreadPoolExecutor.getExecuteExistingDelayedTasksAfterShutdownPolicy()|
  26 |java.util.concurrent.ScheduledThreadPoolExecutor.getQueue()|Returns the task q
  27 |java.util.concurrent.ScheduledThreadPoolExecutor.remove(Runnable)|
  28 |java.util.concurrent.ScheduledThreadPoolExecutor.schedule(Callable<V>,long,TimeUnit)|
  29 |java.util.concurrent.ScheduledThreadPoolExecutor.schedule(Runnable,long,TimeUnit)|
  30 |java.util.concurrent.ScheduledThreadPoolExecutor.scheduleAtFixedRate(Runnable,long,long,TimeUnit)|
  31 |java.util.concurrent.ScheduledThreadPoolExecutor.scheduleWithFixedDelay(Runnable,long,long,TimeUnit)|
  32 |java.util.concurrent.ScheduledThreadPoolExecutor.setContinueExistingPeriodicTasksAfterShutdownPolicy(boolean)|
  33 |java.util.concurrent.ScheduledThreadPoolExecutor.setExecuteExistingDelayedTasksAfterShutdownPolicy(boolean)|
  34 |java.util.concurrent.ScheduledThreadPoolExecutor.shutdown()|Initiates an order
  35 |java.util.concurrent.ScheduledThreadPoolExecutor.shutdownNow()|Attempts to sto
  36 |java.util.concurrent.ScheduledThreadPoolExecutor.submit(Callable<T>)|
  37 |java.util.concurrent.ScheduledThreadPoolExecutor.submit(Runnable)|
  38 |java.util.concurrent.ScheduledThreadPoolExecutor.submit(Runnable,T)|
  39
  40 *java.util.concurrent.ScheduledThreadPoolExecutor_Description*
  41
  42 A (|java.util.concurrent.ThreadPoolExecutor|) that can additionally schedule
  43 commands to run after a given delay, or to execute periodically. This class is
  44 preferable to (|java.util.Timer|) when multiple worker threads are needed, or
  45 when the additional flexibility or capabilities of
  46 (|java.util.concurrent.ThreadPoolExecutor|) (which this class extends) are
  47 required.
  48
  49 Delayed tasks execute no sooner than they are enabled, but without any
  50 real-time guarantees about when, after they are enabled, they will commence.
  51 Tasks scheduled for exactly the same execution time are enabled in
  52 first-in-first-out (FIFO) order of submission.
  53
  54 While this class inherits from (|java.util.concurrent.ThreadPoolExecutor|) , a
  55 few of the inherited tuning methods are not useful for it. In particular,
  56 because it acts as a fixed-sized pool using corePoolSize threads and an
  57 unbounded queue, adjustments to maximumPoolSize have no useful effect.
  58
  59 Extension notes: This class overrides
  60 (|java.util.concurrent.AbstractExecutorService|) submit methods to generate
  61 internal objects to control per-task delays and scheduling. To preserve
  62 functionality, any further overrides of these methods in subclasses must invoke
  63 superclass versions, which effectively disables additional task customization.
  64 However, this class provides alternative protected extension method
  65 decorateTask (one version each for Runnable and Callable) that can be used to
  66 customize the concrete task types used to execute commands entered via execute,
  67 submit, schedule, scheduleAtFixedRate, and scheduleWithFixedDelay. By default,
  68 a ScheduledThreadPoolExecutor uses a task type extending
  69 (|java.util.concurrent.FutureTask|) . However, this may be modified or replaced
  70 using subclasses of the form:
  71
  72
  73
  74 public class CustomScheduledExecutor extends ScheduledThreadPoolExecutor {
  75
  76 static class CustomTask<V> implements RunnableScheduledFuture<V> { ... }
  77
  78 protected <V> RunnableScheduledFuture<V> decorateTask( Runnable r,
  79 RunnableScheduledFuture<V> task) { return new CustomTask<V>(r, task); }
  80
  81 protected <V> RunnableScheduledFuture<V> decorateTask( Callable<V> c,
  82 RunnableScheduledFuture<V> task) { return new CustomTask<V>(c, task); } // ...
  83 add constructors, etc. }
  84
  85
  86
  87 *java.util.concurrent.ScheduledThreadPoolExecutor(int)*
  88
  89 public ScheduledThreadPoolExecutor(int corePoolSize)
  90
  91 Creates a new ScheduledThreadPoolExecutor with the given core pool size.
  92
  93     corePoolSize - the number of threads to keep in the pool, even if they are idle
  94
  95 *java.util.concurrent.ScheduledThreadPoolExecutor(int,RejectedExecutionHandler)*
  96
  97 public ScheduledThreadPoolExecutor(
  98   int corePoolSize,
  99   java.util.concurrent.RejectedExecutionHandler handler)
 100
 101 Creates a new ScheduledThreadPoolExecutor with the given initial parameters.
 102
 103     corePoolSize - the number of threads to keep in the pool, even if they are idle
 104     handler - the handler to use when execution is blocked because the thread bounds and
 105        queue capacities are reached
 106
 107 *java.util.concurrent.ScheduledThreadPoolExecutor(int,ThreadFactory)*
 108
 109 public ScheduledThreadPoolExecutor(
 110   int corePoolSize,
 111   java.util.concurrent.ThreadFactory threadFactory)
 112
 113 Creates a new ScheduledThreadPoolExecutor with the given initial parameters.
 114
 115     corePoolSize - the number of threads to keep in the pool, even if they are idle
 116     threadFactory - the factory to use when the executor creates a new thread
 117
 118 *java.util.concurrent.ScheduledThreadPoolExecutor(int,ThreadFactory,RejectedExecutionHandler)*
 119
 120 public ScheduledThreadPoolExecutor(
 121   int corePoolSize,
 122   java.util.concurrent.ThreadFactory threadFactory,
 123   java.util.concurrent.RejectedExecutionHandler handler)
 124
 125 Creates a new ScheduledThreadPoolExecutor with the given initial parameters.
 126
 127     corePoolSize - the number of threads to keep in the pool, even if they are idle
 128     threadFactory - the factory to use when the executor creates a new thread
 129     handler - the handler to use when execution is blocked because the thread bounds and
 130        queue capacities are reached.
 131
 132 *java.util.concurrent.ScheduledThreadPoolExecutor.decorateTask(Callable<V>,RunnableScheduledFuture<V>)*
 133
 134 protected |java.util.concurrent.RunnableScheduledFuture|<V> decorateTask(
 135   java.util.concurrent.Callable<V> callable,
 136   java.util.concurrent.RunnableScheduledFuture<V> task)
 137
 138 Modifies or replaces the task used to execute a callable. This method can be
 139 used to override the concrete class used for managing internal tasks. The
 140 default implementation simply returns the given task.
 141
 142
 143     callable - the submitted Callable
 144     task - the task created to execute the callable
 145
 146     Returns: a task that can execute the callable
 147
 148 *java.util.concurrent.ScheduledThreadPoolExecutor.decorateTask(Runnable,RunnableScheduledFuture<V>)*
 149
 150 protected |java.util.concurrent.RunnableScheduledFuture|<V> decorateTask(
 151   java.lang.Runnable runnable,
 152   java.util.concurrent.RunnableScheduledFuture<V> task)
 153
 154 Modifies or replaces the task used to execute a runnable. This method can be
 155 used to override the concrete class used for managing internal tasks. The
 156 default implementation simply returns the given task.
 157
 158
 159     runnable - the submitted Runnable
 160     task - the task created to execute the runnable
 161
 162     Returns: a task that can execute the runnable
 163
 164 *java.util.concurrent.ScheduledThreadPoolExecutor.execute(Runnable)*
 165
 166 public void execute(java.lang.Runnable command)
 167
 168 Executes command with zero required delay. This has effect equivalent to
 169 schedule(command, 0, anyUnit). Note that inspections of the queue and of the
 170 list returned by shutdownNow will access the zero-delayed
 171 (|java.util.concurrent.ScheduledFuture|) , not the command itself.
 172
 173
 174     command - the task to execute
 175
 176 *java.util.concurrent.ScheduledThreadPoolExecutor.getContinueExistingPeriodicTasksAfterShutdownPolicy()*
 177
 178 public boolean getContinueExistingPeriodicTasksAfterShutdownPolicy()
 179
 180 Gets the policy on whether to continue executing existing periodic tasks even
 181 when this executor has been shutdown. In this case, these tasks will only
 182 terminate upon shutdownNow or after setting the policy to false when already
 183 shutdown. This value is by default false.
 184
 185
 186
 187     Returns: true if will continue after shutdown
 188
 189 *java.util.concurrent.ScheduledThreadPoolExecutor.getExecuteExistingDelayedTasksAfterShutdownPolicy()*
 190
 191 public boolean getExecuteExistingDelayedTasksAfterShutdownPolicy()
 192
 193 Gets the policy on whether to execute existing delayed tasks even when this
 194 executor has been shutdown. In this case, these tasks will only terminate upon
 195 shutdownNow, or after setting the policy to false when already shutdown. This
 196 value is by default true.
 197
 198
 199
 200     Returns: true if will execute after shutdown
 201
 202 *java.util.concurrent.ScheduledThreadPoolExecutor.getQueue()*
 203
 204 public |java.util.concurrent.BlockingQueue|<Runnable> getQueue()
 205
 206 Returns the task queue used by this executor. Each element of this queue is a
 207 (|java.util.concurrent.ScheduledFuture|) , including those tasks submitted
 208 using execute which are for scheduling purposes used as the basis of a
 209 zero-delay ScheduledFuture. Iteration over this queue is not guaranteed to
 210 traverse tasks in the order in which they will execute.
 211
 212
 213
 214     Returns: the task queue
 215
 216 *java.util.concurrent.ScheduledThreadPoolExecutor.remove(Runnable)*
 217
 218 public boolean remove(java.lang.Runnable task)
 219
 220
 221
 222
 223
 224 *java.util.concurrent.ScheduledThreadPoolExecutor.schedule(Callable<V>,long,TimeUnit)*
 225
 226 public |java.util.concurrent.ScheduledFuture|<V> schedule(
 227   java.util.concurrent.Callable<V> callable,
 228   long delay,
 229   java.util.concurrent.TimeUnit unit)
 230
 231
 232
 233
 234
 235 *java.util.concurrent.ScheduledThreadPoolExecutor.schedule(Runnable,long,TimeUnit)*
 236
 237 public |java.util.concurrent.ScheduledFuture|<?> schedule(
 238   java.lang.Runnable command,
 239   long delay,
 240   java.util.concurrent.TimeUnit unit)
 241
 242
 243
 244
 245
 246 *java.util.concurrent.ScheduledThreadPoolExecutor.scheduleAtFixedRate(Runnable,long,long,TimeUnit)*
 247
 248 public |java.util.concurrent.ScheduledFuture|<?> scheduleAtFixedRate(
 249   java.lang.Runnable command,
 250   long initialDelay,
 251   long period,
 252   java.util.concurrent.TimeUnit unit)
 253
 254
 255
 256
 257
 258 *java.util.concurrent.ScheduledThreadPoolExecutor.scheduleWithFixedDelay(Runnable,long,long,TimeUnit)*
 259
 260 public |java.util.concurrent.ScheduledFuture|<?> scheduleWithFixedDelay(
 261   java.lang.Runnable command,
 262   long initialDelay,
 263   long delay,
 264   java.util.concurrent.TimeUnit unit)
 265
 266
 267
 268
 269
 270 *java.util.concurrent.ScheduledThreadPoolExecutor.setContinueExistingPeriodicTasksAfterShutdownPolicy(boolean)*
 271
 272 public void setContinueExistingPeriodicTasksAfterShutdownPolicy(boolean value)
 273
 274 Sets the policy on whether to continue executing existing periodic tasks even
 275 when this executor has been shutdown. In this case, these tasks will only
 276 terminate upon shutdownNow, or after setting the policy to false when already
 277 shutdown. This value is by default false.
 278
 279
 280     value - if true, continue after shutdown, else don't.
 281
 282 *java.util.concurrent.ScheduledThreadPoolExecutor.setExecuteExistingDelayedTasksAfterShutdownPolicy(boolean)*
 283
 284 public void setExecuteExistingDelayedTasksAfterShutdownPolicy(boolean value)
 285
 286 Sets the policy on whether to execute existing delayed tasks even when this
 287 executor has been shutdown. In this case, these tasks will only terminate upon
 288 shutdownNow, or after setting the policy to false when already shutdown. This
 289 value is by default true.
 290
 291
 292     value - if true, execute after shutdown, else don't.
 293
 294 *java.util.concurrent.ScheduledThreadPoolExecutor.shutdown()*
 295
 296 public void shutdown()
 297
 298 Initiates an orderly shutdown in which previously submitted tasks are executed,
 299 but no new tasks will be accepted. If the
 300 ExecuteExistingDelayedTasksAfterShutdownPolicy has been set false, existing
 301 delayed tasks whose delays have not yet elapsed are cancelled. And unless the
 302 ContinueExistingPeriodicTasksAfterShutdownPolicy has been set true, future
 303 executions of existing periodic tasks will be cancelled.
 304
 305
 306
 307 *java.util.concurrent.ScheduledThreadPoolExecutor.shutdownNow()*
 308
 309 public |java.util.List|<Runnable> shutdownNow()
 310
 311 Attempts to stop all actively executing tasks, halts the processing of waiting
 312 tasks, and returns a list of the tasks that were awaiting execution.
 313
 314 There are no guarantees beyond best-effort attempts to stop processing actively
 315 executing tasks. This implementation cancels tasks via (|java.lang.Thread|) ,
 316 so any task that fails to respond to interrupts may never terminate.
 317
 318
 319
 320     Returns: list of tasks that never commenced execution. Each element of this list is a
 321              {@link ScheduledFuture}, including those tasks submitted using
 322              execute, which are for scheduling purposes used as the basis of a
 323              zero-delay ScheduledFuture.
 324
 325 *java.util.concurrent.ScheduledThreadPoolExecutor.submit(Callable<T>)*
 326
 327 public |java.util.concurrent.Future|<T> submit(java.util.concurrent.Callable<T> task)
 328
 329
 330
 331
 332
 333 *java.util.concurrent.ScheduledThreadPoolExecutor.submit(Runnable)*
 334
 335 public |java.util.concurrent.Future|<?> submit(java.lang.Runnable task)
 336
 337
 338
 339
 340
 341 *java.util.concurrent.ScheduledThreadPoolExecutor.submit(Runnable,T)*
 342
 343 public |java.util.concurrent.Future|<T> submit(
 344   java.lang.Runnable task,
 345   T result)
 346
 347
 348
 349
 350
 351