streamalism.org

1. Overzicht

In dit korte artikel zullen we het hebben over zachte verwijzingen in Java.

We leggen uit wat ze zijn, waarom we ze nodig hebben en hoe we ze kunnen maken.

2. Wat zijn zachte verwijzingen?

Een zacht referentieobject (of een zacht bereikbaar object) kan worden gewist door de Garbage Collector als reactie op een geheugenvraag. Een zacht bereikbaar object heeft geen sterke verwijzingen die ernaar verwijzen.

Wanneer een Garbage Collector wordt gebeld, begint deze te herhalen over alle elementen in de hoop. GC slaat objecten van het referentietype op in een speciale wachtrij.

Nadat alle objecten in de heap zijn gecontroleerd, bepaalt GC welke instanties moeten worden verwijderd door objecten uit de bovengenoemde wachtrij te verwijderen.

Deze regels variëren van de ene JVM-implementatie tot de andere, maar de documentatie stelt dat alle zachte verwijzingen naar zacht bereikbare objecten worden gegarandeerd gewist voordat een JVM een Onvoldoende geheugen fout.

Er worden echter geen garanties gegeven op het moment dat een zachte referentie wordt gewist of de volgorde waarin een reeks van dergelijke verwijzingen naar verschillende objecten wordt gewist.

In de regel kiezen JVM-implementaties tussen het opschonen van recentelijk gemaakte of recentelijk gebruikte referenties.

Zacht bereikbare objecten blijven nog enige tijd in leven nadat er voor het laatst naar is verwezen. De standaardwaarde is een levensduur van één seconde per gratis megabyte in de heap. Deze waarde kan worden aangepast met de -XX: SoftRefLRUPolicyMSPerMB vlag.

Om de waarde bijvoorbeeld te wijzigen in 2,5 seconden (2500 milliseconden), kunnen we gebruiken:

-XX: SoftRefLRUPolicyMSPerMB = 2500

In vergelijking met zwakke referenties kunnen zachte referenties een langere levensduur hebben omdat ze blijven bestaan ​​totdat extra geheugen vereist is.

Daarom zijn ze een betere keuze als we objecten zo lang mogelijk in het geheugen moeten bewaren.

3. Gebruiksscenario's van zachte referenties

Zachte verwijzingen kunnen worden gebruikt voor het implementeren van geheugengevoelige caches waar geheugenbeheer een zeer belangrijke factor is.

Zolang de referent van een zachte referentie sterk bereikbaar is, dat wil zeggen - daadwerkelijk in gebruik is, wordt de referentie niet gewist.

Een cache kan bijvoorbeeld voorkomen dat de meest recent gebruikte vermeldingen worden weggegooid door sterke verwijzingen naar die vermeldingen te bewaren, waarbij de resterende vermeldingen worden weggegooid naar het oordeel van de Garbage Collector.

4. Werken met zachte referenties

In Java wordt een zachte verwijzing weergegeven door de java.lang.ref.SoftReference klasse.

We hebben twee opties om het te initialiseren.

De eerste manier is om alleen een referent door te geven:

StringBuilder builder = nieuwe StringBuilder (); SoftReference reference1 = nieuwe SoftReference (builder);

De tweede optie impliceert het doorgeven van een verwijzing naar een java.lang.ref.ReferenceQueue evenals een verwijzing naar een referent. Referentiewachtrijen zijn bedoeld om ons bewust te maken van acties die worden uitgevoerd door de Garbage Collector. Het voegt een referentieobject toe aan een referentiewachtrij terwijl het besluit de referent van deze referentie te verwijderen.

Hier leest u hoe u een SoftReference met een Referentie wachtrij:

ReferenceQueue referenceQueue = nieuwe ReferenceQueue (); SoftReference reference2 = nieuwe SoftReference (builder, referenceQueue);

Als een java.lang.ref.Reference, het bevat de methoden krijgen en Doorzichtig om respectievelijk een referent op te halen en te resetten:

StringBuilder builder1 = reference2.get (); reference2.clear (); StringBuilder builder2 = reference2.get (); // nul 

Elke keer dat we met dit soort referenties werken, moeten we ervoor zorgen dat een referent, geretourneerd door de krijgen, is aanwezig:

StringBuilder builder3 = reference2.get (); if (builder3! = null) {// GC heeft de instantie nog niet verwijderd} else {// GC heeft de instantie gewist}

5. Conclusie

In deze tutorial maakten we kennis met het concept van zachte referenties en hun gebruiksscenario's.

We hebben ook geleerd hoe we er een kunnen maken en er programmatisch mee kunnen werken.