Perché non esiste un oggetto StrongReference?

Question

Sto implementando un comportamento che potrebbe trarre vantaggio dall'uso di riferimenti deboli in alcuni casi. Vorrei che l'utente della classe fosse in grado di indicare al momento della costruzione se questo è il caso o meno. Dal momento che si estende WeakReferenceReference a prima vista sembrerebbe avrei potuto fare qualcosa di simile (questo è un mockup, non quello che sto effettivamente cercando di fare):

public class Container<T> { 
    private boolean useWeakRef; 
    private Reference<T> ref; 

    public Container(boolean isWeak) { 
     useWeakRef = isWeak; 
    } 

    public void store(T val) { 
     if(useWeakRef) { 
      ref = new WeakReference<>(val); 
     } else { 
      ref = new StrongReference<>(val); 
     } 
    } 

    // May return null 
    public T get() { 
     return ref.get(); 
    } 
} 

Tuttavia non v'è alcuna StrongReference di classe, e secondo la Reference javadocs:

Poiché gli oggetti di riferimento sono attuate in stretta cooperazione con il garbage collector, questa classe non può essere derivata direttamente.

Quindi non posso creare la mia sottoclasse di riferimento che contiene un riferimento forte (ovvero normale) all'oggetto. Ciò sembra significare che non è possibile creare una classe che nasconde se utilizza i riferimenti Weak (o Soft) dal chiamante.

Non capisco veramente perché questa classe non esiste, un oggetto StrongReference deve semplicemente restituire sempre l'oggetto da get() a meno che clear() non sia stato chiamato. Perché manca questo? È un StrongReference incoerente con Reference in qualche modo? Sarebbe molto più semplice costruire oggetti di riferimento generici.

Answer 1

Guava's LocalCache utilizza una classe StrongValueReference che replica ciò che vorrei fare una classe StrongReference. Anche se è un guaio, Guava non espone questo come una classe pubblica, prendo questo come conferma che questa è una caratteristica mancante del JDK, e che è OK replicarla quando necessario.

Detto questo, la maggior parte dei casi di utilizzo che necessitano di astrarre il tipo di riferimenti con cui stanno lavorando sarà probabilmente in grado di utilizzare il comportamento Guava's Cache direttamente, come lo ero io. Incoraggerei chiunque incontrasse questa domanda per esplorare i meccanismi di memorizzazione nella cache di Guava esistenti prima di reinventare da soli questo comportamento di riferimento astratto.

Answer 2

Non è possibile eseguire la sottoclasse di riferimento perché non dispone di costruttori pubblici/protetti. Ma c'è una soluzione:

class StrongReference<T> extends WeakReference<T> { 
    private final T referent; 

    StrongReference(T referent) { 
     super(null); 
     this.referent = referent; 
    } 

    @Override 
    public T get() { 
     return referent; 
    } 

    // implement other methods 
} 

Answer 3

Quando ho bisogno di fare questo, ho appena creato un'interfaccia di riferimento personalizzato e una sottoclasse di banale WeakReference. è fastidioso ma è buono come si può fare.

public interface MyReference<T> { 
    public T get(); 
} 

public class MyWeakReference<T> extends WeakReference<T> implements MyReference<T> { 
} 

public class MyStrongReference<T> implements MyReference<T> { 
    // obvious implementation here ... 
} 

UPDATE:

per chiarire, non ho idea perché questo non è stato incluso nel JDK, in primo luogo (i, anche piaciuto che fosse stata), tuttavia, mi sento questa è una soluzione ragionevole.

per coloro che cercano la giustificazione di questa idea, l'ho trovato necessario quando si implementano cache personalizzate in cui la forza del riferimento fa parte della configurazione per la cache.