В Java его управление памятью включает в себя два аспекта: распределение памяти (при создании объектов Java) и утилизацию памяти. Оба аспекта работы автоматически завершаются JVM, снижая сложность обучения для программистов Java и избегая опасности непосредственно эксплуатационной памяти, такой как C/C ++. Тем не менее, именно потому, что управление памятью полностью обрабатывается JVM, что многие программисты Java больше не заботятся о распределении памяти, в результате чего многие программы неэффективны и потребляют память. Поэтому программисты Java должны понимать JVM в конце, чтобы написать более эффективные программы и в полной мере использовать ограниченную память.
1. Состояние Джавы в памяти
Во -первых, давайте напишем код в качестве примера:
Человек. Ява
Пакет -тест; импорт java.io.serializable; открытый класс лиц реализует сериализуемые {статический окончательный длинный serialversionuid = 1l; String name; // Имя человека друг; // Друзья Public Person () {} Public Perfor (String name) {super (); this.name = name; }} Тест. Ява
Пакет Тест; Общедоступный тест класса {public static void main (string [] args) {person p1 = new Person ("kevin"); Человек P2 = новый человек («дождь»); Человек p3 = новый человек («солнечный»); P1.Friend = P2; P3 = P2; P2 = NULL; }} Если вы нарисуете ссылку на объект в основном аспекте в test.java выше в ссылочную диаграмму объекта, начиная с основного метода, это похоже на это (вершины являются объектами и ссылками, а направленные края являются ссылками
Когда программа работает, после того, как она рассматривается как направленный график, ее можно разделить на три типа:
1) Достижимое состояние: после создания объекта, к нему относится более одной эталонной переменной. На направленном графике вы можете перейти к объекту из исходной вершины, и он находится в доступном состоянии.
2) Восстанавливаемое состояние: если объект в программе больше не имеет каких -либо эталонных переменных, относящихся к нему, он сначала введет восстанавливаемое состояние, и в настоящее время он не может перейти к объекту из исходной вершины направленного графика. В этом состоянии механизм сбора мусора системы готов к переработке памяти, занятой объектом. Перед переработкой система будет вызвать метод завершения () для очистки ресурса. Если после отсортированного ресурса более чем одна эталонная переменная, объект снова станет доступным состоянием; В противном случае он вступит в недоступное состояние.
3) Необщанное состояние: когда все ассоциации объекта отключаются, и система вызывает метод завершения () для очистки ресурса по -прежнему не делает объект, который может быть достижимым состоянием, тогда объект навсегда потеряет ссылку и станет недостижимым состоянием, и система действительно будет утилизировать ресурсы, занятые объектом.
Диаграмма перехода приведенных выше трех состояний заключается в следующем:
2. 4 Ссылки на объекты от Java
1) Сильная ссылка: создайте объект и назначьте этот объект непосредственно переменной, например: Person Person = New Person («Sunny»); Независимо от того, насколько жесткими являются системные ресурсы, сильный ссылочный объект никогда не будет переработан, даже если он не будет использоваться снова в будущем.
2) Мягкая ссылка: реализовано через класс Softreference, например: softreference <dersce> p = новый Softreference <derss> (новый человек («дождь»));, когда память очень жесткая, она будет переработана, и не будет переработана в другое время, поэтому перед использованием, вы должны определить, является ли она нулевой, чтобы определить, не будет переработана.
3) Слабая ссылка: реализовано через класс ShideReference, например: SleaseReference <derss> p = new SleaseReference <Person> (новый человек («дождь»)); Независимо от того, достаточно ли памяти, система определенно будет переработана во время сбора мусора.
4) Виртуальная цитата: ее нельзя использовать отдельно, она в основном используется для отслеживания состояния собранного мусора. Реализовано через класс PhantomReference и класс справочной очереди, например:
Пакет -тест; импорт java.lang.ref.phantomReference; импорт java.lang.ref.referenceue; // Создать справочную очередь reference Queaue <ersont> rq = new Referencequeue <ersont> (); // Создать виртуальную ссылку, пусть эта виртуальная ссылка на объект Person PhantomReference <derss> pr = new PhantomReference <derson> (человек, RQ); // Установите контрольные переменные и объекты личности ссылки Person = null; // Попробуйте получить объект, на который ссылается виртуальная ссылка // Я обнаружил, что программа не может получить доступ к указанному объекту через виртуальную ссылку, поэтому выход здесь - NULL System.out.println (pr.get ()); // Система принудительной сбора мусора.gc (); System.Runfinalization (); // Поскольку после переработки объекта в виртуальной ссылке виртуальная ссылка введет в очередь эталона //, поэтому используйте ссылку, сначала введя очередь в очередь, чтобы сравнить с PR и вывести True System.out.println (rq.poll () == pr); }}
Результаты работы:
3. Механизм сбора мусора Java
Фактически, сборы мусора Java в основном делают две вещи: 1) переработка памяти 2) дефрагментация
3.1 Алгоритм сбора мусора
1) Последовательная переработка (только один процессор) и параллельная переработка (многочисленные процессоры полезны): последовательная переработка означает, что независимо от того, сколько процессоров у системы всегда представляют собой только один процессор для выполнения операций сбора мусора. Параллельная утилизация означает разделение всей работы по переработке на несколько частей, каждая часть отвечает на один процессор, чтобы несколько процессоров можно было переработать параллельно. Параллельная переработка очень эффективна в исполнении, но она увеличивает сложность, и есть также некоторые побочные эффекты, такие как случайное увеличение памяти.
2) Одновременное выполнение и остановка приложения: как следует из названия, его метод сбора мусора приведет к приостановке приложения при выполнении сбора мусора. Несмотря на то, что сборы мусора одновременного выполнения не приведет к приостановке приложения, поскольку одновременное выполнение мусора необходимо разрешить конфликты с приложением (приложение может изменять объекты во время процесса сбора мусора), системные накладные расходы при одновременном выполнении сбора мусора выше, чем у стоп-заседания и требуют большей памяти кучи.
3) Сжатие и не сжатие и копирование:
① Коллекционер мусора, который поддерживает сжатие (Mark-Compression = Mark-Clear + Compression) переместит все достижимые объекты вместе, а затем перерабатывает всю ранее занятую память, уменьшая фрагментацию памяти.
② Коллектор несжатого мусора (маркировку) должен быть пройден дважды. В первый раз, когда вы впервые получаете доступ к всем достижимым объектам и отмечаете их как достойные состояния. Во второй раз, когда вы облегчаете всю область памяти и перерабатывают объекты, которые не отмечены достойными состояниями. Этот метод переработки не сжимается и не требует дополнительной памяти, но он будет создавать фрагментацию, если он потребуется два обхода.
③ Скопируйте сборщик мусора: разделите память кучи на два идентичных пространства, доступ к каждому связанному достопримечательному объекту из корня (аналогично начальной вершине предыдущего направленного графика), скопируйте все достижимые объекты в пространстве A в пространство B, а затем перерабатывают пространство A за один раз. Для этого алгоритма, потому что вам нужно только получить доступ к всем достижимым объектам, копировать все достижимые объекты и непосредственно перерабатывать все пространство, игнорируя вообще недоступные объекты, стоимость пересечения пространства невелика, но это требует огромных затрат на копирование и больше памяти.
3.2 Утилизация поколений памяти кучи
1) Основа для переработки поколений:
① Длина времени выживания объекта: большинство объектов переработаны в течение молодого периода ② Разные поколения применяют разные стратегии переработки мусора: новое (короткое время выживания) старое (длительное время выживания) редко имеют ссылки между объектами
2) генерация памяти кучи:
① Молодое поколение:
«Механизм повреждения: потому что количество объектов мало, используется репликация и переработка.
Ⅱ Область консолидации: она состоит из 1 зоны Eden и 2 зон выживших. Две области выживших одновременно, одна используется для сохранения объекта, а другая пуста; Каждый раз, когда проводится коллекция мусора молодого поколения, доступные объекты в Эдеме и из-за скопируются в область, а некоторые из долгоживущих скопируются в старости, затем Эдем и из космоса очищается, и, наконец, исходное пространство становится от пространства, а оригинал от пространства становится до космоса.
Ⅲ Источник объекта: сначала большинство объектов назначаются в области EDEN, а некоторые крупные объекты будут назначены непосредственно старым поколению.
Ⅳ Частота утилизации: Поскольку большинство объектов молодого поколения быстро попадают в недоступное состояние, частота утилизации высока, а скорость утилизации быстрая.
«Создание»:
«Механизм повреждения: Используйте алгоритм сжатия марки для восстановления.
Ⅱ Источник объектов: 1. Большой объект непосредственно входит в старость.
2. Частота утилизации достижимых объектов с длительным временем выживания в молодом поколении: Поскольку мало объектов умирают, частота выполнения не высока, и для завершения требуется много времени.
③permanune Generation:
Ⅰpurpose: используется для загрузки класса, метода и другой информации. По умолчанию 64 м и не будет переработана. Object Источник: например: для таких рамок, как Hibernate и Spring, которые, как классы динамического генерации AOP, часто генерируют большое количество классов динамических прокси, поэтому необходима более постоянная память. Таким образом, мы часто сталкиваемся с java.lang.outofmemoryerror: ошибка пространства пермина при отладке Hibernate. Это ошибка, вызванная истощением памяти постоянной генерации.
Ⅲ Частота переработки: не будет переработана
3.3 Общие коллекционеры мусора
1) серийный переработчик (используется только один процессор): молодое поколение использует алгоритм последовательных копий; Старое поколение использует алгоритм сжатия последовательной марки (три этапа: Mark Mark - Clear Sweep - Compress Compact), программа будет приостановлена в течение периода утилизации.
2) Параллельный переработчик: алгоритм, используемый для молодого поколения, такой же, как и серийный утилизатор, но он добавляет только параллельную обработку мульти-CPU; Обработка старого поколения точно такая же, как у серийного переработчика, и все еще является единой темой.
3) сборщик параллельного сжатия: обработка молодого поколения точно такая же алгоритм, что и у параллельного коллекционера; Но различные алгоритмы используются для старого поколения, которое фактически разделено на разные области, а затем алгоритм маркировки и сжатия:
① Разделите старое на несколько фиксированных областей;
② Стадия марки (многопоточная параллель), маркировка достижимых объектов;
③ Сводная стадия (серийное исполнение). Когда вы найдете область, которая достигает численного значения (низкая плотность объектов) слева, эта область и ее правая область сжаты и восстанавливаются. Левый конец-это плотная область ④ Компактная стадия (многопоточная параллель), определить области, которые необходимо загрузить, и копировать данные в эти области параллельно. После этого процесса на одном конце старого поколения существует большое количество активных объектов и большой кусок пространства на другом конце.
4) одновременная идентификация - очистка и утилизация (CMS): обработка молодого поколения - это точно тот же алгоритм, что и у параллельных переработчиков; Но различные алгоритмы используются для старого поколения, но алгоритм очистки марки все еще используется:
① Первоначальная идентификация (Program Pause): отмечает объект непосредственно (объект первого уровня);
② Одновременная идентификация (программа запуска): найти другие достижимые объекты через объекты первого уровня;
③ Re-Mark (Program Pause): Многополосные параллельные объекты повторного обозначения, которые могли быть пропущены из-за параллелистики (просто говоря, это анти-пропускание)
④ Одновременная очистка (программа пробегает)
4. Советы по управлению памятью
1) Попробуйте использовать прямое количество, например: String javastr = «Процесс роста ученичества начальной школы»;
2) Используйте StringBuilder и StringBuffer для выполнения конкатенации String и других операций;
3) выпустить бесполезные объекты как можно скорее;
4) попытаться использовать статические переменные как можно меньше;
5) Кэш, обычно используемые объекты: могут быть реализованы с использованием кэша с открытым исходным кодом, например: Oscache, Ehcache;
6) Старайтесь не использовать метод Finalize ();
7) Вы можете рассмотреть возможность использования мягкого эталонного Softreference, когда это необходимо.
Выше всего содержание этой статьи. Я надеюсь, что это будет полезно для каждого обучения, и я надеюсь, что все будут поддерживать Wulin.com больше.