python-ThreadPoolExecutor why task in threadpool will be execute in sequence

def m1():
    for i in range(1,10):
        print("m1 i="+str(i)+" \n")
        time.sleep(0.5)

def m2():
    for i in range(1, 10):
        print("m2 i=" + str(i)+" \n")
        time.sleep(0.5)
def m3():
    for i in range(1,10):
        print("m3 i="+str(i)+" \n")
        time.sleep(0.5)
with ThreadPoolExecutor(max_workers=2) as tp:
    tp.submit(m1())
    tp.submit(m2())
    tp.submit(m3())

I made a threadpool and submitted 3 tasks

Result:

m1 i=1 

m1 i=2 

m2 i=1 

m2 i=2 

m3 i=1 

m3 i=2 

What confused me is that, although I use time.sleep(), the thread is not hang up. All tasks are executed by submit sequence.
Why is that ?

You need to pass a function to the threadpool, without calling it:

with ThreadPoolExecutor(max_workers=2) as tp:
    tp.submit(m1)
    tp.submit(m2)
    tp.submit(m3)

In your case they get executed "on the spot" hence why their execution is sequential.

The answer by @Learningisamess is correct, but I think you should hear it in more detail.

This is a function call:

m1()

You probably already knew that. But maybe what you did not already know is that every function call is an expression. That is, a fragment of code that can be evaluated (i.e., it can be executed to yield a value.)

Here's another expression:

a+3

It is composed of two sub-expressions, a and 3. It is evaluated by first evaluating its sub-expressions, and then adding the two values together. The a is evaluated by fetching the value from a variable named "a," and the 3 is trivial--its value always is 3.

The arguments in a function call expression are sub-expressions too. So, tp.submit(x) first evaluates x, and then it passes that value to the tp.submit function.*

You wrote:

tp.submit(m1())

That will first evaluate the subexpression, m1() by calling the m1 function. Immediately. In the program's main thread. Whatever m1() returns becomes the value of the subexpression. Then finally, tp.submit will be called with whatever m1() returned.

m1() returns None. And tp.submit(None) essentially does nothing. In particular, it does not generate any kind of error. It's pretty much just ignored.

What you really wanted to do is what @Learningisamess said: Write tp.submit(m1) instead. m1 is an expression whose value is the function itself, and tp.submit(m1) tells the thread pool to call that function some time later, and in a different thread.

* In fact, tp, and tp.submit also are sub-expressions of tp.submit(x), but I'm not going to dive all the way to the bottom of that rabbit hole.