In this example is there any real difference or is it just syntactic sugar?

    threads = []
    for job in jobs:
        t = threading.Thread(target=job, args=[exchange])
        t.start()
        threads.append(t)
    for thread in threads:
        thread.join()

And

    with concurrent.futures.ThreadPoolExecutor(max_workers=len(jobs)) as executor:
        for job in jobs:
            executor.submit(job, exchange)

Main point of ThreadPool should be to reuse threads but in this example are all threads exited after "with" statement, Am I right? How to achieve reuse? Keep instance of ThreadPool alive somewhere without with statement?

CodePudding user response：

You can keep the ThreadPool alive somewhere else for as long as you need. But in this particular case you probably want to utilize the result of .submit like this:

with concurrent.futures.ThreadPoolExecutor(max_workers=len(jobs)) as executor:
    futures = []

    for job in jobs:
        future = executor.submit(job, exchange)
        futures.append(future)

    for future in futures:
        future.result()

which is very similar to raw threads, except threads are reused and with future.result() we can retrieve value (if any) and catch exceptions (you may want to try-except the future.result() call).

Btw, I wouldn't do max_workers=len(jobs), it seems to be against the point of ThreadPool. Also I encourage you to have a look at async api instead. Threads are of limited usage in Python anyway.

CodePudding user response：

What you're asking is like asking whether there is any real difference between owning a truck, and renting a truck just on the days when you need it.

A thread is like the truck. A thread pool is like the truck rental company. Any time you create a thread pool, you are indirectly creating threads—probably more than one.

Creating and destroying threads is a costly operation. Thread pools are useful in programs that continually create many small tasks that need to be performed in different threads. Instead of creating and destroying a new thread for each task, the program submits the task to a thread pool, and the thread pool assigns the tasks to one of its worker threads. The worker threads can live a long time. They don't need to be continually created and destroyed because each one can perform any number of tasks.

If the "tasks" that your program creates need to run for almost as long as the whole program itself, Then it might make more sense just to create raw threads for that. But, if your program creates many short-lived tasks, then the thread pool probably is the better choice.