Hoi! Ik denk dat je niet erg verbaasd zou zijn als ik je zou vertellen dat je computer een beperkte hoeveelheid geheugen heeft :)
Zelfs je harde schijf (die vele, vele malen de grootte van RAM is) kan boordevol raken met je favoriete games, tv-programma's en andere dingen. Om dit te voorkomen, moet u de huidige status van het geheugen van uw computer controleren en onnodige bestanden verwijderen. Hoe verhoudt dit alles zich tot Java-programmering? Heel direct! Het maken van een willekeurig object zorgt er immers voor dat de Java-machine er geheugen voor toewijst . Een groot real-world programma maakt tien- of honderdduizenden objecten en voor elk daarvan wordt een stuk geheugen toegewezen. Maar wat denk je, hoeveel van deze objecten bestaan er? Leven ze de hele tijd terwijl ons programma draait? Natuurlijk niet. Zelfs met al hun voordelen zijn Java-objecten niet onsterfelijk :) Objecten hebben hun eigen levenscyclus. Vandaag nemen we een kleine pauze van het schrijven van code en verkennen we dit proces :) Het is ook erg belangrijk om te begrijpen hoe een programma werkt en om bronnen te beheren. Waar begint het leven van een object? Zoals een mens, vanaf de geboorte, dwz wanneer het wordt gemaakt.
Eerst wijst de virtuele Java-machine het geheugen toe dat nodig is om het object te maken. Vervolgens maakt het een verwijzing ernaar (in ons geval cat) om het mogelijk te maken het bij te houden. Vervolgens worden alle variabelen geïnitialiseerd, wordt de constructor aangeroepen en leidt ons nieuwe object nu zijn eigen leven :) De levensduur van objecten varieert. Er zijn hier geen exacte cijfers. In elk geval leeft een object in het programma en vervult het zijn functies gedurende een bepaalde periode. Om precies te zijn, het object is "levend" zolang er verwijzingen naar zijn. Zodra er geen referenties zijn, "sterft" het object. Bijvoorbeeld:
public class Car {
String model;
public Car(String model) {
this.model = model;
}
public static void main(String[] args) {
Car lamborghini = new Car("Lamborghini Diablo");
lamborghini = null;
}
}
Bij de main()methode leeft het auto-object "Lamborghini Diablo" niet meer op de tweede regel. Er was slechts één verwijzing ernaar en de verwijzing was ingesteld op null. Aangezien er geen resterende verwijzingen naar de Diablo zijn, wordt het "vuilnis". Hiervoor hoeft een referentie niet op nul te worden gezet:
public class Car {
String model;
public Car(String model) {
this.model = model;
}
public static void main(String[] args) {
Car lamborghini = new Car("Lamborghini Diablo");
Car lamborghiniGallardo = new Car("Lamborghini Gallardo");
lamborghini = lamborghiniGallardo;
}
}
Hier hebben we een tweede object gemaakt en toegewezen aan de Lamborghini-referentie. Nu wijzen twee verwijzingen naar het Lamborghini Gallardoobject, maar het Lamborghini Diabloobject heeft er geen. Dit betekent dat het Diabloobject afval wordt. Dit is wanneer de ingebouwde Garbage Collector (GC) van Java in werking treedt.
De Garbage Collector is een intern Java-mechanisme dat verantwoordelijk is voor het vrijmaken van geheugen, dwz het verwijderen van onnodige objecten uit het geheugen. We hebben er niet voor niets voor gekozen om het uit te beelden met een robotstofzuiger. De vuilnisophaler werkt op ongeveer dezelfde manier: hij "beweegt" uw programma op de achtergrond om afval op te halen. Je hoeft er praktisch niet mee om te gaan. Het is zijn taak om objecten te verwijderen die niet langer in het programma worden gebruikt. Zo maakt het geheugen vrij voor andere objecten. Weet je nog dat we aan het begin van de les zeiden dat je in het echte leven de staat van je computer moet controleren en oude bestanden moet verwijderen? Als we het hebben over Java-objecten, dan doet de vuilnisophaler dit voor je. De Garbage Collector wordt vele malen gestart terwijl uw programma wordt uitgevoerd: u hoeft het niet expliciet aan te roepen en opdrachten te geven (hoewel dit technisch mogelijk is). We zullen later meer over de vuilnisman praten en in meer detail analyseren hoe het werkt. Wanneer de vuilnisman een object bereikt, net voordat het wordt vernietigd, finalize()wordt de speciale methode van het object aangeroepen. Deze methode kan worden aangeroepen om bepaalde aanvullende bronnen vrij te geven die door het object worden gebruikt. De finalize()methode behoort tot de klasse Object. Met andere woorden, het is vergelijkbaar met equals(), hashCode()en toString()(die je eerder hebt ontmoet). Elk voorwerp heeft het . Het verschilt van andere methoden doordat ... hoe moeten we dit zeggen ... het is zeer eigenzinnig. Daarmee bedoelen we dathet wordt niet altijd aangeroepen voordat een object wordt vernietigd . Programmeren is een zeer precieze bezigheid. De programmeur vertelt de computer om iets te doen, en de computer doet het. Ik neem aan dat je gewend bent geraakt aan dit soort gedrag, dus in het begin kan het moeilijk voor je zijn om het volgende idee te accepteren: "Voordat een object wordt vernietigd, wordt de methode van de klasse Object aangeroepen. Of niet. finalize()Als we geluk hebben! " Toch is dit de realiteit. De Java-machine bepaalt zelf per geval of finalize() moet worden aangeroepen. Laten we bij wijze van experiment proberen de volgende code uit te voeren:
public class Cat {
private String name;
public Cat(String name) {
this.name = name;
}
public Cat() {
}
public static void main(String[] args) throws Throwable {
for (int i = 0 ; i < 1000000; i++) {
Cat cat = new Cat();
cat = null;// The first object becomes available for garbage collection here
}
}
@Override
protected void finalize() throws Throwable {
System.out.println("The Cat is destroyed!");
}
}
We maken een Catobject en in de volgende regel schrappen we de enige verwijzing daarnaar. En dat doen we een miljoen keer. We hebben de finalize()methode expliciet overschreven. Elke keer dat een Catobject wordt vernietigd, moet het een tekenreeks weergeven - in totaal een miljoen keer. Maar nee! Om precies te zijn, op mijn computer werd het slechts 37346 keer uitgevoerd! finalize()Met andere woorden, mijn Java-machine besloot de methode in slechts 1 op de 27 gevallen aan te roepen . In de andere gevallen ging het ophalen van huisvuil niet gepaard met deze oproep. Probeer deze code zelf uit te voeren. Je krijgt hoogstwaarschijnlijk een ander resultaat. Zoals je kunt zien, is het moeilijk om finalize()een betrouwbare partner te noemen :) Dus hier is een kleine tip voor de toekomst: vertrouw niet op de finalize()methode om kritieke bronnen vrij te maken.De JVM kan het noemen, of misschien niet. Wie weet? Als uw object een aantal prestatiekritieke bronnen bevatte (bijvoorbeeld een open databaseverbinding) terwijl het actief was, zou het beter zijn om een speciale methode te maken en expliciet aan te roepen om ze vrij te geven wanneer het object niet langer nodig is. Zo weet je zeker dat de prestaties van je programma er niet onder zullen lijden. We begonnen met te zeggen dat werken met geheugen en afvalinzameling zeer belangrijke onderwerpen zijn, en dat zijn ze ook. Verkeerd omgaan met bronnen en niet begrijpen hoe onnodige objecten worden opgeschoond, kan leiden tot een van de meest onaangename bugs: geheugenlekken . Dit is een van de meest bekende programmeerfouten. Het heeft zelfs een eigen Wikipedia- artikel. Slecht geschreven code kan een situatie creëren waarin elke keer geheugen wordt toegewezen voor nieuw gemaakte objecten, maar oude, onnodige objecten niet beschikbaar zijn voor afvalinzameling. Aangezien we al een analogie met een robotstofzuiger hebben gemaakt, stel je voor wat er zou gebeuren als je, voordat je de robot liet rijden, sokken door het hele huis verspreidde, een glazen vaas kapot sloeg en Lego-stukken overal op de vloer achterliet. Natuurlijk zou de robot iets proberen te doen, maar op een dag zal hij vastlopen.
Om de stofzuiger goed te laten werken, moet je de vloer in goede staat houden en alles oppakken wat hij niet aankan. De vuilnisman volgt hetzelfde principe. Als een programma veel objecten heeft die het niet kan opruimen (zoals een sok of lego voor onze robotstofzuiger), zal op een dag het geheugen opraken. Niet alleen uw programma zal vastlopen, maar ook alle andere programma's die toevallig op de computer draaien. Ze zullen immers ook niet genoeg geheugen hebben (terugkerend naar onze analogie, het gebroken glas op de vloer stopt niet alleen de stofzuiger, maar ook de mensen die in huis wonen). In het kort is dit hoe de levenscyclus van objecten en het ophalen van afval eruit zien in Java. U hoeft dit niet uit uw hoofd te leren: het is voldoende om simpelweg te begrijpen hoe het werkt. In de volgende les gaan we Ik kom op deze processen in meer detail terug. Maar voor nu kun je terugkeren naar het oplossen van CodeGym-taken :) Veel succes!
GO TO FULL VERSION