Wie macht das Java-System Soft References frei?

Question

Ich verwende einen SoftReference-basierten Cache (eine ziemlich einfache Sache an sich). Allerdings habe ich ein Problem beim Schreiben eines Tests dafür gefunden.

Das Ziel des Tests besteht darin, zu überprüfen, ob der Cache das zuvor zwischengespeicherte Objekt erneut vom Server anfordert, nachdem die Speicherbereinigung durchgeführt wurde.

Hier finde ich das Problem, wie das System weiche referenzierte Objekte freigeben kann. Das Aufrufen von System.gc() reicht nicht aus, da weiche Referenzen erst freigegeben werden, wenn der Arbeitsspeicher niedrig ist. Ich führe diesen Komponententest auf dem PC durch, so dass das Speicherbudget für die VM ziemlich groß sein könnte. später

================== Hinzugefügt ========================== ====

Vielen Dank an alle, die darauf geachtet haben, zu antworten!

Schließlich Pro und Contra des bedenkt, dass ich die Brute-Force-Weg zu gehen, entschieden haben, wie von nanda und Jarnbjo beraten. Es scheint jedoch, dass JVM nicht so dumm ist - es wird nicht einmal Müll sammeln, wenn man nach einem Block fragt, der allein größer ist als das Speicherbudget von VM. Also habe ich den Code wie folgt geändert:

/* 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

Sie explizit den weichen Bezug auf null in Ihrem Test einstellen könnte, und als solche simulieren, dass der weiche Bezug freigegeben wurde.

Dies vermeidet jede komplizierte Testkonfiguration, die von Speicher und Speicherbereinigung abhängig ist.

Answer 2

1. Den Parameter -Xmx auf einen sehr kleinen Wert von setzen.
2. Bereiten Sie Ihre weiche Referenz
3. Erstellen Sie so viele Objekte wie möglich. Fragen Sie jedes Mal nach dem Objekt, bis es das Objekt erneut vom Server angefordert hat.

Dies ist mein kleiner Test. Ändern Sie es nach Bedarf.

@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

Statt einer langen Laufschleife (wie von nanda vorgeschlagen), ist es wahrscheinlich schneller und einfacher, einfach eine riesige primitive Array zu erstellen, um mehr Speicher zuzuteilen als verfügbar an die VM, dann fangen und die OutOfMemoryError ignorieren:

Dadurch werden alle schwachen und weichen Referenzen gelöscht, es sei denn, Ihre VM verfügt über mehr als 16 GB verfügbaren Heapspeicher.

Answer 4

Dieser Codeabschnitt zwingt die JVM, alle SoftReferences zu leeren. Und es ist sehr schnell zu tun.

Es funktioniert besser als der Integer.MAX_VALUE Ansatz, da hier die JVM wirklich versucht, so viel Speicher zuzuweisen.

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

Ich benutze jetzt dieses Bit des Codes überall wo ich Testcode mit SoftReferences einheiten muss.

Update: Dieser Ansatz wird in der Tat nur mit weniger als 2G maximalen Speicher arbeiten.

Auch muss man mit SoftReferences sehr vorsichtig sein. Es ist so einfach, versehentlich einen harten Verweis zu behalten, der den Effekt von SoftReferences negiert.

Hier ist ein einfacher Test, der zeigt, dass es jedes Mal auf OSX funktioniert. Wäre daran interessiert zu wissen, ob das Verhalten von JVM unter Linux und Windows das gleiche ist.

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

Eine Verbesserung, die für mehr als 2G maximalen Speicher funktioniert. Es wird wiederholt, bis ein OutOfMemory-Fehler auftritt.