Python - 在異步中取消任務？

Question

我在下面為異步池編寫了代碼。 在__aexit__中，我將在任務完成后取消 _worker 任務。 但是當我運行代碼時，工作任務不會被取消並且代碼會永遠運行。 這是任務的樣子： <Task pending coro=<AsyncPool._worker() running at \async_pool.py:17> wait_for=<Future cancelled>> 。 asyncio.wait_for被取消，但沒有工作任務。

class AsyncPool:
    def __init__(self,coroutine,no_of_workers,timeout):
        self._loop           = asyncio.get_event_loop()
        self._queue          = asyncio.Queue()
        self._no_of_workers  = no_of_workers
        self._coroutine      = coroutine
        self._timeout        = timeout
        self._workers        = None

    async def _worker(self): 
        while True:
            try:
                ret = False
                queue_item           = await self._queue.get()
                ret = True
                result               = await asyncio.wait_for(self._coroutine(queue_item), timeout = self._timeout,loop= self._loop)
            except Exception as e:
                print(e)
            finally:
                if ret:
                    self._queue.task_done()


    async def push_to_queue(self,item):
        self._queue.put_nowait(item)
    
    async def __aenter__(self):
        assert self._workers == None
        self._workers = [asyncio.create_task(self._worker()) for _ in range(self._no_of_workers)]
        return self
    
    async def __aexit__(self,type,value,traceback):
        await self._queue.join()

        for worker in self._workers:
            worker.cancel()

        await asyncio.gather(*self._workers, loop=self._loop, return_exceptions =True)

要使用異步池：

async def something(item):
    print("got", item)
    await asyncio.sleep(item)
 
async def main():
    async with AsyncPool(something, 5, 2) as pool:
        for i in range(10):
            await pool.push_to_queue(i)
 
asyncio.run(main())

我終端中的輸出：

Answer 1

當您創建並取消了asyncio任務時，您仍然有需要“回收”的任務。 所以你想await worker 。 但是，一旦您await這樣一個取消的任務，因為它永遠不會給您返回預期的返回值， asyncio.CancelledError將被引發，您需要在某個地方捕獲它。

由於這種行為，我認為您不應該gather它們，而是await每個取消的任務，因為它們應該立即返回：

async def __aexit__(self,type,value,traceback):
    await self._queue.join()

    for worker in self._workers:
        worker.cancel()
    for worker in self._workers:
        try:
           await worker
        except asyncio.CancelledError:
           print("worker cancelled:", worker)

Answer 2

問題是您的except Exception異常子句也捕獲取消，並忽略它。 為了增加混亂， print(e)只是在CancelledError的情況下打印一個空行，這是輸出中空行的來源。 （將其更改為print(type(e))顯示發生了什么。）

要更正此問題，請將except Exception更改為更具體的內容，例如except asyncio.TimeoutError 。 在 Python 3.8 中不需要此更改，其中asyncio.CancelledError不再派生自Exception ，而是派生自BaseException ，因此except Exception不會捕獲它。

Answer 3

這似乎有效。 該event是一個計數計時器，當它到期時，它會cancels任務。

import asyncio
from datetime import datetime as dt
from datetime import timedelta as td
import random
import time

class Program:
    def __init__(self):
        self.duration_in_seconds = 20
        self.program_start = dt.now()
        self.event_has_expired = False
        self.canceled_success = False

        

    async def on_start(self):
        print("On Start Event Start! Applying Overrides!!!")
        await asyncio.sleep(random.randint(3, 9))


    async def on_end(self):
        print("On End Releasing All Overrides!")
        await asyncio.sleep(random.randint(3, 9))
        

    async def get_sensor_readings(self):
        print("getting sensor readings!!!")
        await asyncio.sleep(random.randint(3, 9))   

 
    async def evauluate_data(self):
        print("checking data!!!")
        await asyncio.sleep(random.randint(3, 9))   


    async def check_time(self):
        if (dt.now() - self.program_start > td(seconds = self.duration_in_seconds)):
            self.event_has_expired = True
            print("Event is DONE!!!")

        else:
            print("Event is not done! ",dt.now() - self.program_start)



    async def main(self):
        # script starts, do only once self.on_start()
        await self.on_start()
        print("On Start Done!")

        while not self.canceled_success:

            readings = asyncio.ensure_future(self.get_sensor_readings())
            analysis = asyncio.ensure_future(self.evauluate_data())
            checker = asyncio.ensure_future(self.check_time())
            
            if not self.event_has_expired:
                await readings   
                await analysis           
                await checker
                
            else:
                # close other tasks before final shutdown
                readings.cancel()
                analysis.cancel()
                checker.cancel()
                self.canceled_success = True
                print("cancelled hit!")


        # script ends, do only once self.on_end() when even is done
        await self.on_end()
        print('Done Deal!')


async def main():
    program = Program()
    await program.main()