Executor Framework

Executor is a tiny interface with one method, execute(Runnable). You hand it a task to run; it decides how and when to run it. This separates submitting work from creating threads, so you don't call new Thread(...).start() everywhere.

Runnable.run() returns nothing and can't throw checked exceptions. Callable<V>.call() returns a value of type V and can throw checked exceptions. Use Callable when the task produces a result you need back.

getPoolSize() is how many threads exist right now, getActiveCount() is how many are currently running a task, and getLargestPoolSize() is the highest pool size ever reached. Together they show how busy the pool is.

The work queue holds tasks that have been submitted but no thread is free to run yet. When the pool and queue are both full and no more work can be taken, the executor rejects new tasks; by default it throws RejectedExecutionException (AbortPolicy).

It is an executor that runs tasks later or repeatedly. You create one with Executors.newScheduledThreadPool(n), then call schedule() for a one-shot delay, or scheduleAtFixedRate/scheduleWithFixedDelay to repeat. Always shut it down when done.

A ThreadPoolExecutor reuses a set of worker threads to run tasks. Its main settings are: core pool size (threads kept alive), maximum pool size (most threads allowed), keep-alive time (how long extra threads idle before stopping), and a work queue that holds waiting tasks.

Its threads are fixed, but the queue that holds waiting tasks is unbounded. If tasks arrive faster than the fixed threads can finish them, the queue grows without limit until the JVM runs out of memory.

execute runs a Runnable and returns nothing (fire-and-forget); if it throws, the exception goes to the thread's uncaught-exception handler. submit accepts a Runnable or Callable and returns a Future you can wait on; any exception is captured inside that Future and re-thrown only when you call get().

ExecutorService adds a lifecycle on top of Executor. shutdown() stops accepting new tasks but lets queued ones finish. shutdownNow() tries to stop immediately and returns the unstarted tasks. awaitTermination() blocks until everything finishes or a timeout passes. You must shut it down, or its threads keep the JVM alive.

shutdown() stops accepting new tasks but lets already-submitted ones finish. shutdownNow() tries to stop running tasks by interrupting them and returns the list of tasks that never started.

Future is a handle to a task's eventual result. future.get() blocks until the task finishes and returns the value (or throws if it failed). The timed get() waits at most a duration. isDone()/isCancelled() check state; cancel() tries to stop it.

Call getQueue().size() to see how many tasks are waiting (the backlog), getCompletedTaskCount() to see how many have finished, and getTaskCount() for the total ever scheduled. A growing queue means the pool can't keep up.

AbortPolicy throws an exception (the default). CallerRunsPolicy runs the task on the thread that submitted it. DiscardPolicy silently drops the task. DiscardOldestPolicy drops the oldest queued task and tries to add the new one. You pick based on whether you want failure, backpressure, or silent dropping.

LinkedBlockingQueue is usually unbounded, so the pool stays at core size and can grow memory unbounded. ArrayBlockingQueue is bounded, so it can trigger pool growth and rejection. SynchronousQueue holds nothing and hands tasks directly to a thread, forcing new threads. PriorityBlockingQueue orders tasks by priority and is unbounded.

FixedRate measures the period from the start of one run to the start of the next, so it tries to run every N units. FixedDelay measures the gap from the end of one run to the start of the next. If a task runs longer than the rate period, fixedRate runs do not overlap (they queue back-to-back) while fixedDelay always leaves the full gap.

If fewer than core threads exist, it starts a new thread. Otherwise it tries to put the task in the queue. If the queue is full, it starts more threads up to the maximum. If the queue is full and threads are at the maximum, the task is rejected.

For CPU-heavy work use about (number of cores + 1) threads, because the CPU is the bottleneck. For I/O-heavy work use more threads, since each thread spends most of its time waiting rather than computing.

If a periodic task throws an uncaught exception, that task is silently cancelled — it never runs again — and you usually see no log. The fix is to wrap the task body in try/catch so the exception never escapes, or inspect the returned ScheduledFuture.

A cached pool makes a new thread for almost every incoming task and has no real upper limit, so a burst of work can create thousands of threads at once — exhausting memory or hitting OS limits, instead of just queuing like a fixed pool.

newScheduledThreadPool returns a pool that can run tasks after a delay or repeatedly on a schedule, using multiple threads. It's preferred over Timer because Timer uses a single thread and one task that throws an exception or runs long can break all the others.

isShutdown() is true once you've called shutdown/shutdownNow. isTerminated() is true only after all tasks have actually finished. awaitTermination() blocks until termination or a timeout, so you call it to wait.

Every schedule call returns a ScheduledFuture. For a one-shot Callable you read its result with get(). For any task you can cancel it with cancel(mayInterruptIfRunning), and check getDelay() to see how long until the next run. Keep the reference if you ever want to stop the task.

Rejection happens when the queue is full and the pool is already at its maximum size (or after shutdown). The built-in policies are: throw an exception (AbortPolicy, the default), run the task on the calling thread (CallerRunsPolicy), silently drop it (DiscardPolicy), or drop the oldest queued task (DiscardOldestPolicy).

The convenient factory methods hide unbounded resources — an unbounded queue (fixed/single) or unbounded threads (cached). Building ThreadPoolExecutor yourself forces you to choose a bounded queue, a thread cap, and what to do when overloaded, so the system fails safely instead of running out of memory.

Both take a collection of Callables. invokeAll runs them all and blocks until every one finishes, returning a list of Futures in the same order. invokeAny runs them and blocks until the first one succeeds, returning that single result and cancelling the rest. Use invokeAll for fan-out/gather; invokeAny when any one good answer suffices.

shutdownNow() only interrupts the worker threads — it sets a flag. A task that never checks that flag or never calls a method that reacts to it just keeps running. You must check the interrupt flag in loops and not swallow InterruptedException.

ExecutorCompletionService hands you results in the order tasks finish, not the order you submitted them. You call take() to get the next completed Future, so a slow task can't block you from processing fast ones that already finished.

Wrap get() to catch InterruptedException and ExecutionException, and read the real failure from getCause(). To stop a task, call cancel(true); the task only stops if its code checks the interrupt flag or calls interruptible methods. Always restore the interrupt flag.

They are overridable methods that run on the worker thread right before and right after each task. You subclass ThreadPoolExecutor and override them to time tasks, log, or set up and clean up thread-local context around every task.