Need real example of circular reference not handled by ref-counting [closed] - garbage-collection

Question

It's difficult to tell what is being asked here. This question is ambiguous, vague, incomplete, overly broad, or rhetorical and cannot be reasonably answered in its current form. For help clarifying this question so that it can be reopened, visit the help center.
Closed 9 years ago.
this may be theoretic a bit, I need this because I am designing my own programming language for fun as a hobby project. I see memory management as "four generations". This is my own view, not connected to any paper or school.
First generation is flat block of memory, and the application just manages it some how.
Second generation is malloc/free style heap. System will handle the memory, but you handle the objects.
Third generation is reference counted allocation/disposal, which happens "in place" or in other words during the call to new/delete.
The fourth generation is what you usually call garbage collector. Which may happen in another thread or sometimes just like third generation may happen during call to new/delete or other procedure.
The main difference is that 4th gen GC will sometimes "walk" or "scan" the heap objects and check out if some of them are "unrooted", so that it can delete tham. This is quite compilcated, there are many algorithms for that "scanning". Sometimes those algoritm names have a word "color" in them. Like "Tri-color marking" or "Tri-color counting async parallel" etc. The most obvious reason for having a "heap scan" is to handle circular references. Because there is no (yet?) other way to handle that.
Ok now to my question.
What could be an easy to understand, "Real life" example of the circular reference, that cannot be handled without the 4th generation GC? Of course you can just type two lines of code, to deliberately create circular reference. But that is not my question. I want a "real" example, I mean something that could happen naturally, and can be easily understood. And something that can really show to any newby how out of the blue you could have a circular reference that you need to handle with GC. Maybe I could use also words "practical" and "useful" to describe such an example.

Answer 1

Since you asked for a real-world example, here's one in Java, using LinkedList:
{
List<String> list = new LinkedList<String>();
list.add("hello");
list.add("world");
}
Why is there a cycle here? because Java's LinkedList is a doubly-linked list, and the implementation of its add is:
boolean add(E e) {
linkLast(e);
return true;
}
void linkLast(E e) {
final Node<E> l = last;
final Node<E> newNode = new Node<>(l, e, null);
last = newNode;
if (l == null)
first = newNode;
else
l.next = newNode;
size++;
modCount++;
}
With this inner class and these fields:
private static class Node<E> {
E item;
Node<E> next;
Node<E> prev;
Node(Node<E> prev, E element, Node<E> next) {
this.item = element;
this.next = next;
this.prev = prev;
}
}
Node<E> first, last;
After the scope ends, list has no references so it can be collected. But the two Nodes created from the two linkLast() invocations have two references each - the first from first and last.prev, the second from last and first.next. Collecting list will only remove 1 of these references for each object, leaving a cycle.