¿Por qué no está LinkedList.Clear() O (1)

Question

Estaba asumiendo que LinkedList.Clear() era O (1) en un proyecto en el que estoy trabajando, ya que utilicé una LinkedList para drenar un BlockingQueue en mi consumidor que necesita un alto rendimiento, borrando y reutilizando LinkedList después.

Resulta que esa suposición era errónea, ya que el (OpenJDK) código hace esto:

Entry<E> e = header.next; 
    while (e != header) { 
     Entry<E> next = e.next; 
     e.next = e.previous = null; 
     e.element = null; 
     e = next; 
    } 

Este fue un poco sorprendente, ¿hay alguna buena razón LinkedList.Clear no podía simplemente "olvidar" su cabecera .next y header.previous miembro?

Answer 1

El código fuente de la versión que estoy viendo (build 1.7.0-EA-B84) en Eclipse tiene este comentario por encima de ellos:

// Clearing all of the links between nodes is "unnecessary", but: 
// - helps a generational GC if the discarded nodes inhabit 
// more than one generation 
// - is sure to free memory even if there is a reachable Iterator 

Eso hace que sea razonablemente claro por qué están haciendo aunque acepto que es un poco alarmante que convierte una operación O (1) en O (n).

Answer 2

Parece que no puedo comentar las respuestas (?): Los punteros entre el siguiente y el anterior no importan. Dado que no se podrá acceder a ninguna de las entradas internas desde ninguna raíz de GC, se recopilará toda la estructura. Si Java hubiera usado un recopilador de recuento, estaríamos atascados con el problema del ciclo.

Las respuestas correctas son las que John Skeet señala.

Answer 3

aunque no estoy muy impresionado con el motivo de la optimización de GC - se vuelve en contra claramente en su caso -

compensación y reutilizar el ListaEnlazada

que no suena bien. ¿por qué no simplemente crear un nuevo objeto LinkedList?