Unexpected Memory Leak in Python 3.10 with Circular References in Custom Objects
I'm reviewing some code and I'm encountering a memory leak in my Python application that seems to be related to circular references in my custom objects... I'm using Python 3.10 and recently introduced a new class structure that involves two classes referencing each other. Despite using `del` to remove references, the memory usage keeps increasing over time, especially when running in a loop that creates and destroys instances of these classes. Here's a simplified version of my classes: ```python class Node: def __init__(self, value): self.value = value self.next_node = None # This will reference another Node class LinkedList: def __init__(self): self.head = None def append(self, value): new_node = Node(value) if not self.head: self.head = new_node else: current = self.head while current.next_node: current = current.next_node current.next_node = new_node def clear(self): current = self.head while current: next_node = current.next_node del current current = next_node self.head = None ``` In my main function, I create instances of `LinkedList` and populate them in a loop: ```python import time for i in range(10000): ll = LinkedList() ll.append(i) ll.clear() time.sleep(0.1) # Just to simulate processing time ``` However, when I monitor the memory usage using `tracemalloc`, I see that it continues to grow. I have read about Python's garbage collection mechanism and tried forcing it with `gc.collect()`, but it doesn't seem to resolve the issue. My suspicion is that the circular references between the `Node` and `LinkedList` objects are preventing the garbage collector from freeing the memory. Could anyone shed light on why this might be happening and how I can effectively address this memory leak? Are there best practices for managing memory with such custom structures in Python? I'm working on a API that needs to handle this.