Ich möchte eine Blockierungsfunktion in einem Executor mit dem asynchronen Aufruf loop.run_in_executor starten und später abbrechen, aber das scheint bei mir nicht zu funktionieren.

Hier ist der Code:

import asyncio
import time

from concurrent.futures import ThreadPoolExecutor


def blocking_func(seconds_to_block):
    for i in range(seconds_to_block):
        print('blocking {}/{}'.format(i, seconds_to_block))
        time.sleep(1)

    print('done blocking {}'.format(seconds_to_block))


@asyncio.coroutine
def non_blocking_func(seconds):
    for i in range(seconds):
        print('yielding {}/{}'.format(i, seconds))
        yield from asyncio.sleep(1)

    print('done non blocking {}'.format(seconds))


@asyncio.coroutine
def main():
    non_blocking_futures = [non_blocking_func(x) for x in range(1, 4)]
    blocking_future = loop.run_in_executor(None, blocking_func, 5)
    print('wait a few seconds!')
    yield from asyncio.sleep(1.5)

    blocking_future.cancel()
    yield from asyncio.wait(non_blocking_futures)



loop = asyncio.get_event_loop()
executor = ThreadPoolExecutor(max_workers=1)
loop.set_default_executor(executor)
asyncio.async(main())
loop.run_forever()

Ich würde erwarten, dass der obige Code nur die Ausgabe der Sperrfunktion zulässt:

blocking 0/5
blocking 1/5

und dann sehen Sie die Ausgabe der nicht blockierenden Funktion. Aber stattdessen geht die blockierende Zukunft weiter, auch nachdem ich abgesagt habe.

Ist es möglich? Gibt es eine andere Möglichkeit?

Vielen Dan

Bearbeiten Weitere Informationen zum Ausführen von blockierendem und nicht blockierendem Code mit asyncio:Wie man blockierenden und nicht blockierenden Code mit asyncio verbindet