Python 异步和线程不能并行工作

Question

I have the following code below, written for testing purposes.

It is just a function to call "5000x factorial(900)" and print the output

It doesn't matter if I use threading or async, they always run one function after the other one, never in parallel.

First one with asyncio:

import asyncio
async def factorial(name, number):
    def fatorial(n):
        if n == 1:
            return 1
        else:
            return n * fatorial(n - 1)
    print(f"START: Task {name}: factorial({number})")
    for i in range(5000):
        var = fatorial(number)
    print(f"FIM: Task {name}: factorial({number})")
    return var

async def main():
    task1 = asyncio.ensure_future(factorial("A", 900))
    task2 = asyncio.ensure_future(factorial("B", 900))
    task3 = asyncio.ensure_future(factorial("C", 900))
    task4 = asyncio.ensure_future(factorial("D", 900))
    await asyncio.gather(task1, task2, task3, task4)


asyncio.run(main())

also tried:

async def main():
    # Schedule three calls *concurrently*:
    task1 = asyncio.create_task(factorial("A", 900))
    task2 = asyncio.create_task(factorial("B", 900))
    task3 = asyncio.create_task(factorial("C", 900))
    task4 = asyncio.create_task(factorial("D", 900))
    await task4


asyncio.run(main())

and also tried with threading:

import threading
def factorial(name, number):
    def fatorial(n):
        if n == 1:
            return 1
        else:
            return n * fatorial(n - 1)
    print(f"START: Task {name}: factorial({number})")
    for i in range(5000):
        var = fatorial(number)
    print(f"FIM: Task {name}: factorial({number})")


threading.Thread(target=factorial("A", 900), daemon=True).start()
threading.Thread(target=factorial("B", 900), daemon=True).start()
threading.Thread(target=factorial("C", 900), daemon=True).start()
threading.Thread(target=factorial("D", 900), daemon=True).start()

and the output is always the same:

START: Task A: factorial(900)
FIM: Task A: factorial(900)
START: Task B: factorial(900)
FIM: Task B: factorial(900)
START: Task C: factorial(900)
FIM: Task C: factorial(900)
START: Task D: factorial(900)
FIM: Task D: factorial(900)

Answer 1

As said in the comments, none of these are good for CPU bound work - but yes, they can run somewhat in parallel - it will just take the amount of time, or a little bit extra, than running then in sequence. Your code is just incorrect in both cases

For the asyncio bit: asyncio just stop one task to run another when it meets an await instruction or equivalent. With no "awaits" your code just run straight until completion, with no chance for task-switching.

await s occur somewht naturally in code that would be optimal to be run as async, as they are placed before the calls to I/O which should take sometime (you await queries to the db server, or an http request, for example). In a CPU bound loop like this, there is nothing to await for, so, if you want to be nice and have other code run in parallel, you have to introduce those "holes". One way of doing it is awaiting for a call to asyncio.sleep . If you put one such call at the end of your inner factorial, you should see it running in parallel:

import asyncio
async def factorial(name, number):
    async def fatorial(n):
        await asyncio.sleep(0)
        if n == 1:
            return 1
        else:
            return n * fatorial(n - 1)
    print(f"START: Task {name}: factorial({number})")
    for i in range(5000):
        var = await fatorial(number)
    print(f"FIM: Task {name}: factorial({number})")
    return var

On the threaded case, there is a different mistake. Unlike async def declared functions, when you are creating a thread with a function as a target you must not call the function. You just pass the function, as an object, to the thread constructor, and the arguments to each separately. The actual function call will take place inside the thread. The way you did it, you just called all functions eagerly, before the call to create each thread even takes place (Everything inside the parenthesis in the call to threading.Thread(...) have to be executed before the call even takes place.

The behavior for "async def functions" (the proper name is "coroutine function") is different: the call syntax (eg factorial() ) resolves but this do not run any code - rather, the call do a corotine function yields a coroutine object - which then can be awaited or wrapped in a task or future: only them the code in the function body will actually be executed.

So, for the threaded code, the changes are these:

threading.Thread(target=factorial, args=("A", 900), daemon=True).start()
threading.Thread(target=factorial, args=("B", 900), daemon=True).start()
threading.Thread(target=factorial, args=("C", 900), daemon=True).start()
threading.Thread(target=factorial, args=("D", 900), daemon=True).start()

Now, if you have a multicore machine, you can change your threading example for a multiprocessing example, take the same care when creating the Process instances, and you should see your execution time fall proportionally to the number of physical CPU cores you have. (up to 4, as you are creating only 4 parallel tasks)

Answer 2

If you simplify the inner function it can be easier to see what is happening. Like this.

import asyncio
import time

async def factorial(name, number):
    print(f"START: Task {name}: factorial({number})")
    if True:  # or False - change manually
        await asyncio.sleep(1.0)
    else:
        time.sleep(1.0)
    print(f"FIM: Task {name}: factorial({number})")

async def main():
    task1 = asyncio.ensure_future(factorial("A", 900))
    task2 = asyncio.ensure_future(factorial("B", 900))
    task3 = asyncio.ensure_future(factorial("C", 900))
    task4 = asyncio.ensure_future(factorial("D", 900))
    await asyncio.gather(task1, task2, task3, task4)

asyncio.run(main())

When True (and not CPU bound)

START: Task A: factorial(900)
START: Task B: factorial(900)
START: Task C: factorial(900)
START: Task D: factorial(900)
FIM: Task A: factorial(900)
FIM: Task C: factorial(900)
FIM: Task B: factorial(900)
FIM: Task D: factorial(900)

When False (also not CPU bound)

START: Task A: factorial(900)
FIM: Task A: factorial(900)
START: Task B: factorial(900)
FIM: Task B: factorial(900)
START: Task C: factorial(900)
FIM: Task C: factorial(900)
START: Task D: factorial(900)
FIM: Task D: factorial(900)

The difference is that awaiting the asyncio.sleep hands back control to the event loop. Calling time.sleep does not.