I wrote an article on how to do batch processing with multithreads in Python last week but there are things that my sample code wasn’t handling.

- Handle results from the threaded function.
- Handle exceptions from the threaded function.

With these 2 points in mind, I rewrote the sample code.

```
from concurrent.futures import ThreadPoolExecutor
from concurrent import futures
import time
def task(n):
print(f"processing {n}")
if n % 5 == 0:
raise Exception("It is divisible by 5")
time.sleep(1)
return True
def main():
print("Starting ThreadPoolExecutor")
tasks = []
fs = []
for i in range(23):
tasks.append(task)
with ThreadPoolExecutor(max_workers=5) as executor:
for i, t in enumerate(tasks):
future = executor.submit(t, i)
fs.append(future)
results = futures.wait(fs)
for result in results.done:
if result.done():
print(f"{result.done()}")
if result.exception() is not None:
print(f"Handle exception here: {result.exception()}")
if __name__ == '__main__':
start_time = time.time()
main()
elapsed_time = time.time() - start_time
print(f"Took {elapsed_time}")
```

Here is the output:

```
Starting ThreadPoolExecutor
processing 0
processing 1
processing 2
processing 3
processing 4
processing 5
processing 6
processing 7
processing 8
processing 9
processing 10
processing 11
processing 12
processing 13
processing 14
processing 15
processing 16
processing 17
processing 18
processing 19
processing 20
processing 21
processing 22
True
Handle exception here: It is divisible by 5
True
True
True
Handle exception here: It is divisible by 5
True
True
Handle exception here: It is divisible by 5
True
True
True
True
True
True
True
True
True
True
Handle exception here: It is divisible by 5
True
True
True
True
True
True
Handle exception here: It is divisible by 5
True
Took 4.017247915267944
```

This way, you can handle situations where you are expecting certain results from the threaded function and also exception situation. The previous sample did not have any of those, so this sample is a better one. Also it is easier to specify the number of concurrent threads.