Come rendere la versione di sistema java Soft References?

Question

Utilizzerò una cache basata su SoftReference (una cosa piuttosto semplice di per sé). Tuttavia, mi sono imbattuto in un problema durante la scrittura di un test per questo.

L'obiettivo del test è verificare se la cache fa richiedere nuovamente l'oggetto memorizzato in precedenza dal server dopo la pulizia della memoria.

Qui trovo il problema di come rendere il sistema in grado di rilasciare oggetti di riferimento morbidi. Chiamare System.gc() non è sufficiente perché i riferimenti software non verranno rilasciati fino a quando la memoria non è in esaurimento. Sto eseguendo questo test unitario sul PC, quindi il budget di memoria per la VM potrebbe essere abbastanza grande.

================== aggiunti in seguito ========================== ====

Grazie a tutti coloro che si sono premurati di rispondere!

Dopo aver considerato tutto di contra pro e ho deciso di andare il modo in cui la forza bruta come consigliato dal Nanda e jarnbjo. È apparso, tuttavia, che JVM non è così stupido - non tenterà nemmeno di raccogliere i rifiuti se chiedete un blocco che da solo è più grande del budget di memoria della VM. Così ho modificato il codice come questo:

/* Force releasing SoftReferences */ 
    try { 
     final List<long[]> memhog = new LinkedList<long[]>(); 
     while(true) { 
      memhog.add(new long[102400]); 
     } 
    } 
    catch(final OutOfMemoryError e) { 
     /* At this point all SoftReferences have been released - GUARANTEED. */ 
    } 

    /* continue the test here */ 

Answer 1

è possibile impostare in modo esplicito il riferimento morbido per nulla nel test, e come tale di simulare che il riferimento morbido è stato rilasciato.

Ciò evita qualsiasi configurazione di test complicata che dipende dalla memoria e dalla garbage collection.

Answer 2

1. Impostare il parametro -Xmx su un valore molto piccolo .
2. Prepara il tuo morbido riferimento
3. creare il numero di oggetto come possibile. Richiedi l'oggetto ogni volta fino a quando non chiede nuovamente l'oggetto al server.

Questo è il mio piccolo test. Modifica come richiesto.

@Test 
public void testSoftReference() throws Exception { 
    Set<Object[]> s = new HashSet<Object[]>(); 

    SoftReference<Object> sr = new SoftReference<Object>(new Object()); 

    int i = 0; 

    while (true) { 
     try { 
      s.add(new Object[1000]); 
     } catch (OutOfMemoryError e) { 
      // ignore 
     } 
     if (sr.get() == null) { 
      System.out.println("Soft reference is cleared. Success!"); 
      break; 
     } 
     i++; 
     System.out.println("Soft reference is not yet cleared. Iteration " + i); 
    } 
} 

Answer 3

Invece di un ciclo lungo in esecuzione (come suggerito da Nanda), probabilmente è più facile e veloce per creare semplicemente una vasta gamma primitiva di allocare più memoria di quella disponibile al VM, poi prendere e ignorare l'OutOfMemoryError:

try { 
     long[] foo = new long[Integer.MAX_VALUE]; 
    } 
    catch(OutOfMemoryError e) { 
     // ignore 
    } 

Questo cancellerà tutti i riferimenti deboli e deboli, a meno che la VM non abbia più di 16 GB di heap disponibile.

Answer 4

Questo pezzo di codice forza la JVM a svuotare tutte le SoftReferences. Ed è molto veloce da fare.

Sta funzionando meglio dell'approccio Integer.MAX_VALUE, poiché qui la JVM cerca davvero di allocare quella quantità di memoria.

try { 
    Object[] ignored = new Object[(int) Runtime.getRuntime().maxMemory()]; 
} catch (OutOfMemoryError e) { 
    // Ignore 
}

Ora utilizzo questo bit di codice ovunque sia necessario il codice di test dell'unità utilizzando SoftReferences.

Aggiornamento: questo approccio funzionerà effettivamente solo con meno di 2G di memoria massima.

Inoltre, è necessario essere molto attenti con SoftReferences. È così facile mantenere per errore un riferimento difficile che annullerà l'effetto di SoftReferences.

Ecco un semplice test che mostra che funziona ogni volta su OSX. Sarebbe interessato a sapere se il comportamento di JVM è lo stesso su Linux e Windows.

for (int i = 0; i < 1000; i++) { 
    SoftReference<Object> softReference = new SoftReferencelt<Object>(new Object()); 
    if (null == softReference.get()) { 
     throw new IllegalStateException("Reference should NOT be null"); 
    } 

    try { 
     Object[] ignored = new Object[(int) Runtime.getRuntime().maxMemory()]; 
    } catch (OutOfMemoryError e) { 
     // Ignore 
    } 

    if (null != softReference.get()) { 
     throw new IllegalStateException("Reference should be null"); 
    } 

    System.out.println("It worked!"); 
}

Answer 5

Un miglioramento che funzionerà per più di 2 G max di memoria. Ciclo finché non si verifica un errore OutOfMemory.

@Test 
public void shouldNotHoldReferencesToObject() { 
    final SoftReference<T> reference = new SoftReference<T>(...); 

    // Sanity check 
    assertThat(reference.get(), not(equalTo(null))); 

    // Force an OoM 
    try { 
     final ArrayList<Object[]> allocations = new ArrayList<Object[]>(); 
     int size; 
     while((size = Math.min(Math.abs((int)Runtime.getRuntime().freeMemory()),Integer.MAX_VALUE))>0) 
      allocations.add(new Object[size]); 
    } catch(OutOfMemoryError e) { 
     // great! 
    } 

    // Verify object has been garbage collected 
    assertThat(reference.get(), equalTo(null)); 

}