If I have a garbage collector that tracks every object allocated and deallocates them as soon as they no longer have usable references to them can you still have a memory leak?
Considering a memory leak is allocations without any reference isn’t that impossible or am I missing something?
Edit: So what I’m counting as a memory leak is allocations which you no longer have any reference to in the code. Large numbers of accumulating allocations which you still have references to aren’t the leaks I’m considering here.
I’m also only talking about normal state of the art G.C., It’s been a while but I know cases like cyclical references don’t trip them up. I don’t need a specific answer for any language, this is just coming from a conversation I was having with a friend. We were talking about Actionscript and Java but I don’t care for answers specific to those.
Edit2: From the sounds of it, there doesn’t seem to be any reason code can completely lose the ability to reference an allocation and not have a GC be able to pick it up, but I’m still waiting for more to weigh in.
If your question is really this:
Then the answer is “yes, that’s impossible” because a properly implemented garbage collector will reclaim all allocations that don’t have active references.
However, you can definitely have a “memory leak” in (for example) Java. My definition of a “memory leak” is an allocation that still has an active reference (so that it won’t be reclaimed by the garbage collector) but the programmer doesn’t know that the object isn’t reclaimable (ie: for the programmer, this object is dead and should be reclaimed). A simple example is something like this:
In this example, ObjectA is an object in active use in the code. However, ObjectA contains a reference to ObjectB that is effectively dead (ie: ObjectB has been allocated and used and is now, from the programmer’s perspective, dead) but the programmer forgot to set the reference in ObjectA to null. In this case, ObjectB has been “leaked”.
Doesn’t sound like a big problem, but there are situations where these leaks are cumulative. Let’s imagine that ObjectA and ObjectB are actually instances of the same class. And this problem that the programmer forgot to set the reference to null happens every time such an instance is used. Eventually you end up with something like this:
Now ObjectB through ObjectH are all leaked. And problems like this will (eventually) cause your program to crash. Even with a properly implemented garbage collector.