A thread pool can run tasks concurrently and still return their results in input order. In Python, use Executor.map() for the simplest ordered-result workflow; use indexed futures when you need to handle each task as soon as it finishes. In Java, ExecutorService.invokeAll() returns futures in the order of the supplied task list.
What “preserve task order” means
Task order can refer to when tasks start, when they finish, or the order in which the caller receives their results. A thread pool does not guarantee that tasks start or finish in input order: scheduling and task duration can vary. If you need an ordered output, associate each result with its original position or use an API that returns results in input order.
This distinction matters when later tasks finish first. They may already be complete even though an ordered consumer is still waiting for an earlier task.
Python: use Executor.map() for ordered results
For a function applied to one or more input iterables, Executor.map() is the concise choice. It runs calls asynchronously and may run them concurrently, while its iterator yields results in the order of the input values. See the Python 3.14 concurrent.futures documentation.
The Tool Desk
Outbyte PC Repair FREEClear out junk files and repair common Windows errorsFree Scan →Outbyte Driver Updater FREEFix the driver behind crashes, sound loss and screen glitchesFind Drivers →#1 Best Overall
from concurrent.futures import ThreadPoolExecutor
def work(item):
return transform(item)
with ThreadPoolExecutor(max_workers=8) as pool:
results = list(pool.map(work, items))The first result yielded corresponds to the first input, the second to the second input, and so on. This is result ordering, not a promise that tasks execute sequentially.
Bound outstanding work in Python 3.14
Python 3.14 added the buffersize parameter to Executor.map(). It limits the number of submitted tasks whose results have not yet been yielded. When that buffer is full, iteration over the input pauses until a result is yielded.
with ThreadPoolExecutor(max_workers=8) as pool:
results = list(pool.map(work, items, buffersize=16))Choose a buffer limit appropriate to your workload and memory needs. The chunksize parameter has no effect for ThreadPoolExecutor.
Know when ordered iteration can pause
If the task for the first input is slow, the iterator cannot yield a later task’s result before it. Later work may already be finished, but ordered delivery waits for the earlier position. That trade-off is useful when output order matters; it can be inconvenient when prompt handling of any completed task matters more.
Handle exceptions when retrieving results
With map(), an exception raised by a task is raised when the corresponding result is retrieved from the iterator. If the caller needs to respond to failures, consume the iterator in a way that handles those exceptions rather than assuming every result will be produced successfully.
Python: submit tasks and put results back by index
Use individual submissions when tasks need custom handling or when you want to process completions as they happen. Save each task’s input index, then write its result into that slot as its future completes. Python’s as_completed() yields futures in completion order; the index mapping restores input order in the final list.
from concurrent.futures import ThreadPoolExecutor, as_completed
results = [None] * len(items)
with ThreadPoolExecutor(max_workers=8) as pool:
future_to_index = {
pool.submit(work, item): index
for index, item in enumerate(items)
}
for future in as_completed(future_to_index):
index = future_to_index[future]
results[index] = future.result()Here, completion order controls when each slot is filled, while the list’s indices preserve input order. Calling future.result() retrieves the outcome and raises that task’s exception if it failed.
When retaining futures in submission order is enough
You can also create a list of futures in input order and call result() on each one in that order. That produces results in input order, but retrieving an early, slow future can block the caller while later futures are already complete. Prefer the index-and-as_completed() pattern when you need to react promptly to each completion.
Recommended Free Tools
Best Value
- Complete 4 month log book for commercial pool and spa water conditions
- Easy to track pH, FAC, Bather Load, Pressure, Flow Rate, Backwashing, and more
- Two-days per page or two pools per page
- Heavy duty plastic cover - pages feature a plastic core that are tear, water, and grease resistant
- Designed to use poolside with little to no-risk
Java: use invokeAll() for a batch
Java’s ExecutorService.invokeAll(tasks) returns a list of futures in the sequential order of the supplied task list. Each returned future is complete when invokeAll() returns. Retrieve their values in list order to build an ordered result collection. The API contract is documented in the Java SE 26 ExecutorService documentation.
This approach fits batch work when waiting for the submitted tasks as a group is acceptable. Do not assume that APIs named map, bulk submission, or futures in other languages guarantee the same ordering; check the documentation for the specific library and runtime version.
Choose an approach based on how results will be consumed
| Approach | Result order | When it fits | Trade-off |
|---|---|---|---|
Python Executor.map() |
Input order | Apply a function to input iterables and collect results in sequence. | Yielding a later result can wait behind an earlier slow task. |
Python futures plus as_completed() and indices |
Completion handling; final list in input order | Handle each finished task promptly while assembling an ordered collection. | Requires an index-to-future association and explicit result placement. |
| Python futures retained in submission order | Input order | Collect a small or straightforward batch without custom completion handling. | Calling result() on an early unfinished future can block later retrieval. |
Java ExecutorService.invokeAll() |
Future list in task-list order | Wait for a batch, then retrieve values in sequence. | The method returns futures once the batch’s tasks are complete. |
Check the runtime and plan for shutdown
The guarantees above are tied to the documented APIs and versions: the Python details here refer to Python 3.14, and the Java example to Java SE 26. Verify behavior against the version you deploy, especially if you use another language or executor library.
In Python, using an executor as a context manager waits for pending work when the block exits. If a program can leave the block early, account for that shutdown behavior when designing cancellation or timeout handling; an ordered result strategy alone does not stop outstanding tasks.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
