what is garbage collection java
Този урок обяснява какво представлява събирането на боклук в Java и как работи Garbage Collector. Също така ще научите за алгоритмите за събиране на боклука:
Читателите, които познават C / C ++, трябва да са наясно, че програмистът е отговорен да създава и изтрива обектите в C / C ++.
Сериозни грешки възникват, ако програмистът забрави да унищожи създадените обекти. Това е така, защото неспособността да се унищожат обектите може да доведе до „ Недостиг на памет ”Грешки, изтичане на памет и др.
Тази ситуация е напълно обгрижвана в Java, тъй като няма нужда програмист да следи обектите. Java се грижи за унищожаването на обекти за нас чрез автоматично събиране на боклука.
=> Посетете тук, за да научите Java от нулата.
Процесът, при който обектите, които вече не се използват, се премахват от купчината памет, се нарича „Събиране на боклук“. Техниката за събиране на боклука е част от управлението на паметта в Java.
По този начин в Java, Garbage Collector унищожава всички обекти, които вече не се използват.
Какво ще научите:
- Какво представлява събирачът на боклук в Java?
- Как работи събирането на боклука в Java?
- Алгоритми за събиране на боклука в Java
- Заключение
Какво представлява събирачът на боклук в Java?
Събирането на боклук в Java се управлява от програма, наречена Garbage Collector.
Garbage Collector може да бъде дефиниран като програма, която се използва за автоматично управление на паметта чрез обработка на де-разпределението на обекта.
Знаем, че на езика Java новите обекти се създават и разпределят памет с помощта на новия оператор. Паметта, разпределена за обект с помощта на нов оператор, остава разпределена, докато препратките използват този обект.
Веднага щом препратките престанат да съществуват, паметта, която обектът заема, се възстановява. След това Java се справя автоматично с разпределението или унищожаването на обекти и не е необходимо изрично да унищожаваме обекта.
Тази техника е техниката за събиране на боклук в Java, където програмистите не трябва да се справят изрично с освобождаването на обекти.
Имайте предвид, че ако програмите не разпределят паметта, когато обектите не се нуждаят от нея, тогава в крайна сметка няма да остане памет за разпределяне и програмите ще се сринат. Тази ситуация се нарича изтичане на памет.
Събирачът на боклук винаги работи във фонов режим на демонова нишка. Събирачът на боклук се счита за най-добрият пример за демоновата нишка.
Garbage Collector работи с намерение да освободи паметта на купчината. Той прави това, като унищожава обектите, които са „недостижими“.
Какво е „недостижим“ обект?
Обектът става недостижим, когато дори няма нито една препратка, свързана с него.
Помислете за следния код:
Integer ref_obj = new Integer (5); //ref_obj is a reference to Integer ref_obj = null; //Integer object now becomes unreachable
Както се вижда от горния код, обектът е достъпен, стига референцията да е свързана с него. В момента, в който референтната асоциация бъде премахната (настройка за нула в горния случай), обектът е недостъпен.
Когато даден обект стане недостъпен, той става допустим за Събиране на боклук (GC).
Как можем да направим обект допустим за GC?
Въпреки че от програмиста не се изисква да унищожава обектите, тъй като за тях се грижи GC, поне програмистът може да направи тези обекти недостъпни, когато вече не са необходими.
По този начин GC ще събере недостижимите предмети и ще ги унищожи.
Има няколко начина да направите обект допустим за GC, като го направите недостъпен.
Те са:
# 1) Анулиране на референцията
Като се има предвид препратка, присвоена на обект, ако този обект вече не е необходим, тогава присвоете препратката на null.
Student s = new Student (); s = null;
Когато s е зададено за нула, обектът Student става недостижим.
# 2) Преназначете Референцията
Това е друг начин да направите обектите допустими за GC.
Обмислете следния код.
Student s1 = new Student (); Student s2 = new Student (); s1 = s2;
Сега, когато сме присвоили s1 на друг обект, обектът Student, на който се позовава s1, е дереферендиран.
# 3) Създайте анонимен обект
Чрез създаването на анонимен обект можем да направим обектите допустими за GC.
Можем да създадем анонимен обект, както е показано по-долу:
new Student();
След като направим обектите допустими за GC, тези обекти могат или не могат да бъдат унищожени незабавно от GC. Това е така, защото не можем изрично да принудим GC да изпълнява както и когато искаме.
Кога работи Колектор за боклук?
От JVM зависи да стартира програмата Garbage Collector. Когато JVM стартира Garbage Collector, недостижимите обекти се унищожават. Но все пак не можем да гарантираме кога ще работи JVM.
Въпреки че не можем да принудим GC да изпълни, много добре можем да поискаме събиране на боклук.
GC може да бъде поискан, използвайки някой от следните методи.
# 1) System.gc (): Класът System на Java предоставя статичен метод gc (), с който можем да поискаме JVM да стартира Garbage Collector.
# 2) Runtime.getRuntime (). Gc (): Подобно на System.gc (), ние също можем да използваме метода gc () от “Runtime class”, за да поискаме от JVM да стартира Garbage Collector.
Забележка: Няма гаранция, че Събирачът на боклук ще работи след заявка от тези два метода.
Финализиране
Финализирането се извършва от Garbage Collector непосредствено преди унищожаването на обектите. Като част от техниката за финализиране, Garbage Collector извиква метода finalize () на обекта. Методът finalize () се използва за извършване на дейности по почистване.
Методът finalize () се предоставя от класа “Object” и има следния прототип.
protected void finalize () throws Throwable
Методът finalize () се извиква винаги, когато обектът е събран боклук
Забележка: Събирачът на боклук събира само обектите, които са създадени с помощта на новата ключова дума. За други обекти трябва да използваме метода finalize (), за да извършим почистването.
Програмата по-долу показва просто събиране на боклука в Java.
class TestGC{ @Override // finalize method: called on object once // before garbage collecting it protected void finalize() throws Throwable { System.out.println('Garbage collector called'); System.out.println('Object garbage collected : ' + this); } } class Main{ public static void main(String args[]){ TestGC gc1=new TestGC(); TestGC gc2=new TestGC(); gc1 = null; //nullify gc1 System.gc(); //request for GC to run gc2 = null; //nullify gc2 Runtime.getRuntime().gc(); //request for GC to run } }
Изход
В горната програма създадохме клас TestGC. В този клас сме заменили метода finalize (). След това в основния клас създаваме два обекта от клас TestGC. Първо, обезсилваме обект и извикваме System.gc (), за да поискаме Garbage Collector.
След това обезсилваме втория обект и извикваме метода Runtime.getRuntime.gc (), за да поискаме Garbage Collector. Изходът показва изхода на метода за финализиране два пъти, като по този начин показва, че Събирачът на боклук е работил два пъти.
Забележка: Въпреки че имаме този изход, не е гарантирано, че всеки път ще получим същия изход. Напълно зависи от JVM.
Как работи събирането на боклука в Java?
В този раздел ще видим как Събирането на боклук работи в Java.
По време на събирането на боклука, Събирачът на боклук търси паметта на купчината и след това „маркира“ недостъпните обекти. След това ги унищожава.
Но проблемът възниква, когато броят на обектите се увеличава. Тъй като обектите се увеличават, времето, необходимо за събиране на боклука, също се увеличава, тъй като търси недостъпни обекти. Това обаче не засяга твърде много, тъй като повечето обекти имат кратък живот.
Поведението по-горе се извиква „Генерационно събиране на боклук“ и трябва да подобри производителността на JVM. При този подход цялото пространство на купчината е разделено на - младо поколение, старо поколение или постоянно поколение и постоянно поколение.
# 1) Пространство на купчина от младо поколение: Всички нови обекти са създадени в това пространство. След като пространството се запълни, се извършва Minor GC, при което всички мъртви предмети се унищожават. Малкият GC процес е бърз и бърз, тъй като повечето обекти са мъртви. Обектите, оцелели от младото поколение, се преместват в по-старите поколения.
# 2) Пространство на купчина от старо поколение: Това поколение съхранява обекти, които оцеляват дълго. Когато прагът на възрастта, зададен за младото поколение е изпълнен, обектът се премества в старото поколение. Когато пространството от старо поколение се запълни, се извършва главен GC.
Основната GC е бавна, тъй като обектите, участващи тук, са живи обекти. Понякога цялото пространство на Heap, което включва млади, както и стари поколения, се изчиства. Това се нарича „Пълен GC“.
# 3) Постоянно поколение L. До Java 7 някога е имало постоянно поколение (Perm Gen). Метаданните, държани от Пермски генерал, се използват от JVM. JVM използва тези метаданни, за да опише класове и методи, използвани в приложението. Perm Gen е премахнат в Java 8.
Събиране на боклук Java 8: Perm Gen и Metaspace
Вече споменахме за пространството на Perm Gen, което присъстваше до Java 7. Въпреки това, сега в Java 8, JVM представлява метаданните на класа, използвайки естествената памет, наречена „Metaspace“.
Освен Metaspace, има нов флаг, наречен “MaxMetaspaceSize”, който ограничава паметта, използвана за метаданни на класа. Ако не е посочена стойност за MaxMetaspaceSize, тогава Metaspace я преоразмерява по време на изпълнение в съответствие с търсенето на приложението.
Когато пространството с метаданни на класа достигне MaxMetaspaceSize, се задейства MetaCpace GC. Когато има прекомерен Metaspace GC, това показва изтичане на памет на класове, classloaders и т.н., както и неадекватно оразмеряване.
Алгоритми за събиране на боклука в Java
Съществуват различни начини, по които се извършва Събирането на боклука. В този раздел ще представим четири такива начина или алгоритми за събиране на боклук в Java.
Сериен GC
Serial GC е най-простият GC алгоритъм. Работи главно при малки размери на купчина и еднонишкови системи. Докато работи, Serial GC замразява всички приложения.
За да включим Serial GC, можем да използваме следната опция JVM.
какво е план за изпитване в qa
java –xx:+UseSerialGC –jar Application.java
Горната команда може да бъде дадена в командния ред. Тук Application.java е файл, за който трябва да се активира сериен GC.
Пропускателна способност / паралелен GC
THE Parallel GC алгоритъм е алгоритъмът по подразбиране в JDK 8. Този алгоритъм използва множество нишки за сканиране на купчината пространство и уплътняване. Този алгоритъм е подходящ най-вече за приложения, които могат да се справят с паузи на нишки и да оптимизират режийните разходи на процесора.
Един недостатък на паралелния GC е, че докато изпълнява малък или пълен GC, алгоритъмът поставя на пауза нишките на приложението.
Събирачът на CMS
CMS означава „ Съвместно почистване на Марк ”. Този алгоритъм използва множество едновременно нишки за сканиране на купчината ( марка ) за идентифициране на неизползвани обекти и рециклиране ( метене ) тях. Колекторът на CMS има режим Stop-The-World (STW).
Колекторът преминава в този режим в два сценария:
- Когато обекти, принадлежащи към старото поколение, могат да бъдат достигнати от статични променливи или точки за въвеждане на нишки. Така че този режим е включен по време на инициализацията на първоначалните коренни маркировки.
- Когато алгоритъмът работи едновременно, приложението променя състоянието и принуждава колектора да се върне, за да се увери, че са маркирани правилните обекти.
Събирачът на CMS обаче може да страда от „неуспешни промоции“. И така, какво е промоционален провал? Ако обектите от пространството на младото поколение се преместят в старото поколение и колекторът не е направил достатъчно място за тези обекти в пространството от купчина от старото поколение, тогава ще възникне промоционален провал.
За да предотвратим промоционален неуспех, можем да предоставим повече фонови нишки на колектора или да осигурим по-голям размер на купчината на старото поколение.
Колекторът G1
Колекторът G1 е „Първият боклук“. Проектиран е за размери на купчина над 4GB. Въз основа на размера на купчината, той разделя размера на купчината на региони с размери, вариращи от 1MB до 32MB.
Колекторът G1 маркира обектите в зависимост от жизнеността на обектите в цялата купчина. След тази фаза на маркиране G1 е наясно с празните региони. По този начин той събира недостъпните обекти от тези региони, като по този начин освобождава голямо количество пространство. Следователно той е наречен като Garbage-First, тъй като първо събира региони, съдържащи боклук.
Той също така отговаря на дефинираната от потребителя цел за време на пауза, като използва модел за предсказване на пауза, като избира броя на регионите за събиране в зависимост от посочената цел за време на пауза.
Предимство на събирането на боклука
- Събирането на боклук прави управлението на паметта в Java ефективно, тъй като премахва нереферираните обекти от паметта на купчината без намесата на програмиста.
- Тъй като събирането на боклука е автоматично и е част от JVM, не са необходими допълнителни усилия от програмиста за възстановяване на паметта или унищожаване на обекти.
- Програмистът не трябва да пише какъвто и да е специфичен код, за да отдели паметта и да изтрие обекти, както е направено в C / C ++.
често задавани въпроси
В # 1) Каква е ролята на Събирач на боклук?
Отговор: В Java Garbage Collector е основната страна в управлението на паметта и има за задача да събира недостъпните обекти и да възстановява паметта.
В # 2) Какво имате предвид под Събиране на боклук?
Отговор: Събирането на боклук е техниката, чрез която паметта се управлява автоматично чрез възстановяване на неизползваната памет. Това е функция, присъстваща в езици за програмиране като Java, поради което програмистите не трябва да следят неизползваните обекти и да ги унищожават. Това се извършва автоматично, като се използва Garbage Collection.
Q # 3) Кой е отговорен за събирането на боклука в Java?
Отговор: Управлението на паметта на Java носи отговорността за събирането на боклука.
Q # 4) Как можем да предотвратим събирането на боклука в Java?
Отговор: Тъй като Събирачът на боклук не възстановява паметта на променливи / обекти, които са живи, най-добрият начин да се предотврати събирането на боклук е да се използват променливи / обекти в цялата програма.
Q # 5) Как можете да се уверите, че даден обект се събира в боклука?
Отговор: Обектът отговаря на условията за Събиране на боклук, когато е недостъпен, т.е. когато няма повече препратки, отнасящи се до обекта. Въпреки че не можем да принудим Garbage Collector да работи, когато пожелаем, винаги можем да поискаме да се стартира с помощта на System.gc ().
Заключение
Събирането на боклук в Java, което обсъдихме в този урок, е автоматично и програмистът не трябва да се занимава с изтриването на обектите или променливите, разпределени в програмата.
Автоматичното събиране на боклука в Java е най-важната характеристика на езика и е част от управлението на паметта в Java.
Въпреки че Събирането на боклук се извършва от JVM и е извън обсега на програмиста, ние винаги можем да поискаме Garbage Collector да стартира, използвайки метода gc () от клас System и Runtime.
В този урок обсъдихме процеса на финализиране, който се извършва преди обектите да бъдат унищожени от Garbage Collector. Също така обсъдихме процеса на събиране на боклука в Java. И накрая, обсъдихме различните алгоритми, използвани от Garbage Collector.
Това завършва нашата дискусия за Garbage Collector в Java.
=> Внимавайте тук за простия сериал за обучение на Java.
Препоръчително четене
- Основи на Java: Синтаксис на Java, клас Java и основни концепции на Java
- За какво се използва Java: 12 Java приложения в реалния свят
- Java урок за низове | Низови методи на Java с примери
- Урок за JAVA за начинаещи: 100+ практически ръководства за Java видео
- Java компоненти: Java платформа, JDK, JRE и Java виртуална машина
- Разполагане на Java: Създаване и изпълнение на Java JAR файл
- Java виртуална машина: Как JVM помага при стартирането на Java приложение
- Урок за отражение на Java с примери