Fix asyncio memory leak in cancelled tasks and add validation tests

Clear callback chains and exception references in Task._step() to prevent reference retention

Filter cancelled Task objects from event loop's ready queue in BaseEventLoop._run_once()

Add TestTaskMemoryLeak test case to verify proper garbage collection of cancelled tasks

Include module-level docstring explaining test purpose and methodology

Addresses memory management issues reported in Issue python#129204

Author: tangyuan0821

Lib/asyncio/tasks.py

@@ -263,28 +263,6 @@ def __eager_start(self):
                 else:
                     _register_task(self)
 
-    def __step(self, exc=None):
-        if self.done():
-            raise exceptions.InvalidStateError(
-                f'__step(): already done: {self!r}, {exc!r}')
-        if self._must_cancel:
-            if not isinstance(exc, exceptions.CancelledError):
-                exc = self._make_cancelled_error()
-            self._must_cancel = False
-        self._fut_waiter = None
-
-        _enter_task(self._loop, self)
-        try:
-            self.__step_run_and_handle_result(exc)
-        finally:
-            if self.done():
-                # Clear the callback chain and residual references
-                self._callbacks.clear()  # Clean up the callback list
-                self._exception = None  # Release the reference to the exception object
-                if hasattr(self, '_context'):
-                    self._context = None  # Python 3.11+ Clean up context variables
-            _leave_task(self._loop, self)
-            self = None  # Needed to break cycles when an exception occurs.
 
     def __step_run_and_handle_result(self, exc):
         coro = self._coro

Lib/test/test_asyncio/test_taskgroups.py

@@ -1117,30 +1117,4 @@ def loop_factory():
 if __name__ == "__main__":
     unittest.main()
 
-"""
-This test case verifies that cancelled asyncio tasks are properly garbage collected
-and do not cause memory leaks. It creates a large number of tasks, cancels them,
-and checks for remaining Task objects after garbage collection.
-"""
 
-import unittest
-import asyncio
-import gc
-
-class TestTaskMemoryLeak(unittest.TestCase):
-    async def test_cancelled_task_cleanup(self):
-        async def dummy():
-            await asyncio.sleep(0.1)
-
-        # Create and cancel 10,000 tasks
-        tasks = [asyncio.create_task(dummy()) for _ in range(10_000)]
-        for t in tasks:
-            t.cancel()
-
-        # Wait for all tasks to complete cleanup
-        await asyncio.gather(*tasks, return_exceptions=True)
-        del tasks
-
-        # Trigger garbage collection and verify memory release
-        gc.collect()
-        self.assertEqual(len([obj for obj in gc.get_objects() if isinstance(obj, asyncio.Task)]), 0)

Lib/test/test_asyncio/test_tasks.py

@@ -3615,4 +3615,28 @@ def tearDown(self):
 if __name__ == '__main__':
     unittest.main()
 
+"""
+This test case verifies that cancelled asyncio tasks are properly garbage collected
+and do not cause memory leaks. It creates a large number of tasks, cancels them,
+and checks for remaining Task objects after garbage collection.
+"""
 
+
+
+class TestTaskMemoryLeak(unittest.TestCase):
+    async def test_cancelled_task_cleanup(self):
+        async def dummy():
+            await asyncio.sleep(0.1)
+
+        # Create and cancel 10,000 tasks
+        tasks = [asyncio.create_task(dummy()) for _ in range(10_000)]
+        for t in tasks:
+            t.cancel()
+
+        # Wait for all tasks to complete cleanup
+        await asyncio.gather(*tasks, return_exceptions=True)
+        del tasks
+
+        # Trigger garbage collection and verify memory release
+        gc.collect()
+        self.assertEqual(len([obj for obj in gc.get_objects() if isinstance(obj, asyncio.Task)]), 0)