Что такое ссылка в java

Виды ссылок на объекты в Java

Рассмотрим пример когда эти классы могут понадобиться.

Здесь можно пойти разными путями, рассмотрим некоторые:

1. можно следить за тем, когда объект перестает использоваться на клиенте и затем удалять его из коллекции. Однако, это решение требует многих изменений в логике работы клиента, и будет идеально чтобы другие классы работали с этими объектами прозрачно.

2. Использовать механизм «слабых ссылок» в Java.

Что это за «слабые ссылки»?

В Java ссылки можно разделить по «силе». Далее представлены все 4 типа ссылок отсортированных по «силе» (от большей к меньшей):

1. сильные ссылки (strong reference). Это обычные ссылки которые мы всегда используем. Когда мы объявляем Rectangle rect = new Rectangle(), то объект на который ссылается rect не может быть удален сборщиком мусора из памяти до тех пор, пока на этот объект есть хотя бы одна сильная ссылка;

2. мягкие ссылки (SoftReference). Объявление мягкой ссылки выглядит так:

SoftReference rect = new SoftReference (new Rectangle());

Для получения самого объекта Rectangle можно воспользоваться методом rect.get(). Метод get() объявлен у класса Reference, от которого наследуются SoftReference, WeakReference, PhantomReference. Важно понимать, что метод get() может вернуть null. Это происходит в том случае, когда память вашей программы заполнена и появляется вероятность возникновения OutOfMemoryError, тогда сборщик мусора удаляет объекты на которые ссылаются мягкие ссылки. Именно этот вид ссылок удобно использовать для кеширования объектов.

3. слабые ссылки (WeakReference). Использование слабой ссылки схоже с использованием мягкой ссылки, объявление:

WeakReference rect = new WeakReference (new Rectangle());

Разница в том, что объект на который ссылается слабая ссылка может быть удален в любой момент при вызове cборщика мусора, т.е. для этого не обязательно условие нехватки памяти.

4. фантомные ссылки (PhantomReference). Создание фантомной ссылки аналогично другим:

new PhantomReference (new Rectangle(), queue);

Метод get() вызванный у фантомной ссылки всегда возвращает null. Это связано с тем для чего они используются.

Дело в том, что слабая ссылка помещается в очередь перед тем, как объект на который она указывает будет финализирован (finalize()) и удален сборщиком мусора. Т.е. в методе finalize() удаляемого объекта можно назначить строгую ссылку на удаляемый объект, и таким образом «спасти» его от сборщика мусора. Но слабая ссылка уже будет в очереди и будет уничтожена.

Рассмотрим слабые ссылки на практическом примере.

Объекты на которые будут указывать наши ссылки представлены классом BigObject.

Для тестирования используются следующие объекты:

Для вывода результатов тестов будем использовать следующие методы:

Методы инициализации и загрузки памяти выглядят так:

Теперь проведем тестирование. Для первого теста используем следующий код:

В результате получаем:

Пояснение: Как ранее говорилось, фантомные ссылки всегда возвращают null. После вызова сборщика мусора были удалены объекты на которые ссылались фантомные ссылки (PhantomReference) и слабые ссылки (WeakReference).
Во втором тесте рассмотрим момент удаления объектов на которые ссылаются мягкие ссылки (SoftReference). Тест представлен кодом:

В результате получаем:

Пояснение: На первом этапе после вызова сборщика мусора были удалены объекты на которые указывали слабые ссылки (WeakReference). Далее происходит загрузка памяти и повторный вызов сборщика мусора. После этого удаляются объекты на которые указывали мягкие ссылки (SoftReference). В результате после этих действий остались объекты только с прямыми (сильными) ссылками на них.

Использование различных видов ссылок в Java позволяет уменьшить вероятность возникновения утечек памяти (memory leaks), а также повысить эффективность использования памяти. Для реализации кеша можно использовать класс WeakHashMap.

Берегите память!
Иван Каплин, февраль 2010.

Если Вам понравилась статья, проголосуйте за нее

Источник

Ссылочные типы и примеры методов Java

Ссылка на метод Java была введена в Java 8 вместе с лямбда-выражениями. Ссылка на метод-это быстрый способ создания лямбда-выражений, когда он

Ссылка на метод Java была введена в Java 8 вместе с лямбда-выражениями. Ссылка на метод-это быстрый способ создания лямбда-выражений, когда он просто вызывает метод.

Что такое Ссылка на метод Java?

Ссылка на метод позволяет нам создать лямбда-выражение из существующего метода. Он используется, когда лямбда – выражение вызывает функцию и больше ничего не делает. JVM заботится о создании лямбда-выражения путем сопоставления входных переменных с аргументами метода.

Синтаксис Ссылки на метод

Ссылка на метод состоит из двух частей – класса/объекта и метода/конструктора. Они разделены двойными двоеточиями (::). Дополнительные параметры, передаваемые со ссылкой на метод, отсутствуют.

Типы ссылок на методы

В Java существует четыре типа ссылок на методы.

Ссылочные типы методов Java

Примеры ссылок на методы Java

Давайте рассмотрим примеры всех четырех типов ссылок на методы. Сначала мы создадим лямбда-выражение, а затем используем ссылку на метод, чтобы добиться того же эффекта.

1. Ссылка на Статический Метод

Допустим, у нас есть функциональный интерфейс, как показано ниже.

У нас есть класс Utils для получения количества элементов в массиве.

Мы будем использовать лямбда-выражение для вызова метода Utils class count Elements (), чтобы получить количество элементов в массиве.

Здесь лямбда-выражение просто вызывает статический метод класса Utils и больше ничего не делает. Это идеальное место для использования ссылки на метод для вызова статического метода.

2. Ссылка на Метод Экземпляра объекта

Давайте изменим реализацию класса Utils и создадим метод экземпляра.

Теперь мы создадим лямбда-выражение, вызывающее этот метод экземпляра.

Мы можем заменить лямбда-выражение ссылкой на метод экземпляра.

Мы можем создать экземпляр класса Utils в самой ссылке на метод.

3. Ссылка на метод экземпляра произвольного объекта

Иногда мы вызываем метод аргумента в лямбда-выражении. В этом случае мы можем использовать ссылку на метод для вызова метода экземпляра произвольного объекта определенного типа.

Допустим, у нас есть такое лямбда-выражение.

Здесь лямбда-выражение просто вызывает метод. Итак, мы можем использовать ссылку на метод здесь. Но метод вызывается для произвольного объекта String. Таким образом, мы можем вызвать метод экземпляра, обратившись к классу String.

4. Ссылка на метод Конструктора

Метод Stream collect() принимает аргумент поставщика. Поставщик должен каждый раз возвращать новый экземпляр. Таким образом, лямбда-выражение должно вызывать конструктор. Давайте рассмотрим простой пример.

Что ж, нам не нужно здесь останавливаться. Два других лямбда-выражения также могут быть заменены ссылкой на метод.

Источник

Типы ссылок в Java: StrongReference, WeakReference, SoftReference и PhantomReference

В Java есть 4 типа ссылок: Strong — сильная ссылка (мы чаще всего ею пользуемся) и 3 типа специальных ссылок: WeakReference, SoftReference и PhantomReference. В этой статье мы узнаем зачом они нужны и где их желательно использовать.

Типы ссылок в Java

Сборщик мусора в Java чаще всего работает со Strong References или же сильными ссылками. Там все понятно и просто: создаем ссылку на объект, что-то делаем с ним и потом, когда ссылка будет указывать на null и других ссылок на этот объект не будет — освобождаем память.

Любой объект, к которому прилагается Сильная ссылка, не имеет права на сбор мусора. Например:

Здесь ссылочная переменная title имеет сильную ссылку на объект String «Программирование на Java«;

В других случаях сборщику мусора нужно принять решение на основании того, какие ссылки ссылаются на этот объект.

WeakReference и SoftReference в Java

Для начала давайте рассмотрим разницу между WeakReference и SoftReference в Java.

Если вкратце, то сборщик мусора освободит память объекта, если на него указывают только слабые ссылки. Когда на объект указывают ссылки SoftReferences, то освобождение памяти происходит, когда JVM сильно нуждается в памяти.

Это дает определенное преимущество SoftReference перед Strong ссылкой в определенных случаях. Например, SoftReference используют для реализации кэша приложений, поэтому JVM первым делом удалит объекты, на которые указывают только SoftReferences.

WeakReference отлично подходит для хранения метаданных, например, для хранения ссылки на ClassLoader. Если ни один класс не загружен, то не стоит ссылаться на ClassLoader. Именно поэтому WeakReference делает возможность сборщику мусора выполнить свою работу с ClassLoader, как только на него удалится последняя сильная ссылка.

Пример WeakReference в Java:

Пример SoftReference в Java:

Ссылка PhantomReference в Java

Экземпляр PhantomReference создается точно также, как и на примерах WeakReference и SoftReference, но используется он довольно редко.

PhantomReference может быть собрана сборщиком мусора, если на объект нет сильных (Strong), слабых ссылок (WeakReference) или мягких (SoftReference).

PhantomReference может использоваться в ситуациях, когда использование finalize() не имеет смысла. Этот ссылочный тип отличается от других типов, поскольку он не предназначен для доступа к объекту. Он является сигналом о том, что объект уже финализирован и сборщик мусора готов вернуть свою память.

Для этого сборщик мусора помещает его в специальный ReferenceQueue для последующей обработки. ReferenceQueue — это место, куда помещаются ссылки на объекты для освобождение памяти.

Фантомные ссылки — это безопасный способ узнать, что объект удален из памяти. Например, рассмотрим приложение, которое имеет дело с большими изображениями. Предположим, что мы хотим загрузить изображение в память, когда оно уже находится в памяти, которая готова для сборки мусора. В этом случае мы хотим подождать пока сборщик мусора убьет старое изображение и только потом загружать в память новое.

Здесь PhantomReference является гибким и безопасным выбором. Ссылка на старое изображение будет передана в ReferenceQueue после уничтожения старого объекта изображения. Получив эту ссылку, мы можем загрузить новое изображение в память.

Если вы узнали что-то новое из этой статьи про типы ссылок в Java, то подпишитесь на рассылку, чтобы ничего не пропустить, а также на обновления сайта в соц. сетях — там публикуется больше интересных и полезных материалов!

Источник

Управление памятью Java

Это глубокое погружение в управление памятью Java позволит расширить ваши знания о том, как работает куча, ссылочные типы и сборка мусора.

Вероятно, вы могли подумать, что если вы программируете на Java, то вам незачем знать о том, как работает память. В Java есть автоматическое управление памятью, красивый и тихий сборщик мусора, который работает в фоновом режиме для очистки неиспользуемых объектов и освобождения некоторой памяти.

Поэтому вам, как программисту на Java, не нужно беспокоиться о таких проблемах, как уничтожение объектов, поскольку они больше не используются. Однако, даже если в Java этот процесс выполняется автоматически, он ничего не гарантирует. Не зная, как устроен сборщик мусора и память Java, вы можете создать объекты, которые не подходят для сбора мусора, даже если вы их больше не используете.

Для начала давайте посмотрим, как обычно организована память в Java:

Структура памяти

Стек (Stack)

Стековая память отвечает за хранение ссылок на объекты кучи и за хранение типов значений (также известных в Java как примитивные типы), которые содержат само значение, а не ссылку на объект из кучи.

Кроме того, переменные в стеке имеют определенную видимость, также называемую областью видимости. Используются только объекты из активной области. Например, предполагая, что у нас нет никаких глобальных переменных (полей) области видимости, а только локальные переменные, если компилятор выполняет тело метода, он может получить доступ только к объектам из стека, которые находятся внутри тела метода. Он не может получить доступ к другим локальным переменным, так как они не выходят в область видимости. Когда метод завершается и возвращается, верхняя часть стека выталкивается, и активная область видимости изменяется.

Возможно, вы заметили, что на картинке выше отображено несколько стеков памяти. Это связано с тем, что стековая память в Java выделяется для каждого потока. Следовательно, каждый раз, когда поток создается и запускается, он имеет свою собственную стековую память и не может получить доступ к стековой памяти другого потока.

Куча (Heap)

Эта часть памяти хранит в памяти фактические объекты, на которые ссылаются переменные из стека. Например, давайте проанализируем, что происходит в следующей строке кода:

Ключевое слово new несет ответственность за обеспечение того, достаточно ли свободного места на куче, создавая объект типа StringBuilder в памяти и обращаясь к нему через «Builder» ссылки, которая попадает в стек.

Для каждого запущенного процесса JVM существует только одна область памяти в куче. Следовательно, это общая часть памяти независимо от того, сколько потоков выполняется. На самом деле структура кучи немного отличается от того, что показано на картинке выше. Сама куча разделена на несколько частей, что облегчает процесс сборки мусора.

Типы ссылок

Если вы внимательно посмотрите на изображение структуры памяти, вы, вероятно, заметите, что стрелки, представляющие ссылки на объекты из кучи, на самом деле относятся к разным типам. Это потому, что в языке программирования Java используются разные типы ссылок: сильные, слабые, мягкие и фантомные ссылки. Разница между типами ссылок заключается в том, что объекты в куче, на которые они ссылаются, имеют право на сборку мусора по различным критериям. Рассмотрим подробнее каждую из них.

1. Сильная ссылка

Это самые популярные ссылочные типы, к которым мы все привыкли. В приведенном выше примере со StringBuilder мы фактически храним сильную ссылку на объект из кучи. Объект в куче не удаляется сборщиком мусора, пока на него указывает сильная ссылка или если он явно доступен через цепочку сильных ссылок.

2. Слабая ссылка

Попросту говоря, слабая ссылка на объект из кучи, скорее всего, не сохранится после следующего процесса сборки мусора. Слабая ссылка создается следующим образом:

После сбора мусора ключа из WeakHashMap вся запись удаляется из карты.

3. Мягкая ссылка

Подобно слабым ссылкам, мягкая ссылка создается следующим образом:

4. Фантомная ссылка

Ссылки на String

Ссылки на тип String в Java обрабатываются немного по- другому. Строки неизменяемы, что означает, что каждый раз, когда вы делаете что-то со строкой, в куче фактически создается другой объект. Для строк Java управляет пулом строк в памяти. Это означает, что Java сохраняет и повторно использует строки, когда это возможно. В основном это верно для строковых литералов. Например:

При запуске этот код распечатывает следующее:

Следовательно, оказывается, что две ссылки типа String на одинаковые строковые литералы фактически указывают на одни и те же объекты в куче. Однако это не действует для вычисляемых строк. Предположим, что у нас есть следующее изменение в строке // 1 приведенного выше кода.

Strings are different

При добавлении вышеуказанного изменения создается следующий результат:

Процесс сборки мусора

Как обсуждалось ранее, в зависимости от типа ссылки, которую переменная из стека содержит на объект из кучи, в определенный момент времени этот объект становится подходящим для сборщика мусора.

Объекты, подходящие для сборки мусора

Например, все объекты, отмеченные красным цветом, могут быть собраны сборщиком мусора. Вы можете заметить, что в куче есть объект, который имеет строгие ссылки на другие объекты, которые также находятся в куче (например, это может быть список, который имеет ссылки на его элементы, или объект, имеющий два поля типа, на которые есть ссылки). Однако, поскольку ссылка из стека потеряна, к ней больше нельзя получить доступ, так что это тоже мусор.

Чтобы углубиться в детали, давайте сначала упомянем несколько вещей:

Этот процесс запускается автоматически Java, и Java решает, запускать или нет этот процесс.

На самом деле это дорогостоящий процесс. При запуске сборщика мусора все потоки в вашем приложении приостанавливаются (в зависимости от типа GC, который будет обсуждаться позже).

На самом деле это более сложный процесс, чем просто сбор мусора и освобождение памяти.

Несмотря на то, что Java решает, когда запускать сборщик мусора, вы можете явно вызвать System.gc() и ожидать, что сборщик мусора будет запускаться при выполнении этой строки кода, верно?

Это ошибочное предположение.

Вы только как бы просите Java запустить сборщик мусора, но, опять же, Java решать, делать это или нет. В любом случае явно вызывать System.gc() не рекомендуется.

Поскольку это довольно сложный процесс и может повлиять на вашу производительность, он реализован разумно. Для этого используется так называемый процесс «Mark and Sweep». Java анализирует переменные из стека и «отмечает» все объекты, которые необходимо поддерживать в рабочем состоянии. Затем все неиспользуемые объекты очищаются.

Так что на самом деле Java не собирает мусор. Фактически, чем больше мусора и чем меньше объектов помечены как живые, тем быстрее идет процесс. Чтобы сделать это еще более оптимизированным, память кучи на самом деле состоит из нескольких частей. Мы можем визуализировать использование памяти и другие полезные вещи с помощью JVisualVM, инструмента, поставляемого с Java JDK. Единственное, что вам нужно сделать, это установить плагин с именем Visual GC, который позволяет увидеть, как на самом деле структурирована память. Давайте немного увеличим масштаб и разберем общую картину:

Поколения памяти кучи

Когда объект создается, он размещается в пространстве Eden (1). Поскольку пространство Eden не такое уж большое, оно заполняется довольно быстро. Сборщик мусора работает в пространстве Eden и помечает объекты как живые.

Если объект выживает в процессе сборки мусора, он перемещается в так называемое пространство выжившего S0(2). Во второй раз, когда сборщик мусора запускается в пространстве Eden, он перемещает все уцелевшие объекты в пространство S1(3). Кроме того, все, что в настоящее время находится на S0(2), перемещается в пространство S1(3).

Если объект выживает в течение X раундов сборки мусора (X зависит от реализации JVM, в моем случае это 8), скорее всего, он выживет вечно и перемещается в пространство Old(4).

Принимая все сказанное выше, если вы посмотрите на график сборщика мусора (6), каждый раз, когда он запускается, вы можете увидеть, что объекты переключаются на пространство выживших и что пространство Эдема увеличивалось. И так далее. Старое поколение также может быть обработано сборщиком мусора, но, поскольку это большая часть памяти по сравнению с пространством Eden, это происходит не так часто. Метапространство (5) используется для хранения метаданных о ваших загруженных классах в JVM.

Представленное изображение на самом деле является приложением Java 8. До Java 8 структура памяти была немного другой. Метапространство на самом деле называется PermGen область. Например, в Java 6 это пространство также хранит память для пула строк. Поэтому, если в вашем приложении Java 6 слишком много строк, оно может аварийно завершить работу.

Типы сборщиков мусора

Фактически, JVM имеет три типа сборщиков мусора, и программист может выбрать, какой из них следует использовать. По умолчанию Java выбирает используемый тип сборщика мусора в зависимости от базового оборудования.

3. Mostly concurrent GC (В основном параллельный сборщик мусора). Если вы помните, ранее в этой статье упоминалось, что процесс сбора мусора на самом деле довольно дорогостоящий, и когда он выполняется, все потоки приостанавливаются. Однако у нас есть в основном параллельный тип GC, который утверждает, что он работает одновременно с приложением. Однако есть причина, по которой он «в основном» параллелен. Он не работает на 100% одновременно с приложением. Есть период времени, на который цепочки приостанавливаются. Тем не менее, пауза делается как можно короче для достижения наилучшей производительности сборщика мусора. На самом деле существует 2 типа в основном параллельных сборщиков мусора:

Примечание переводчика. Информация про сборщики мусора для различных версий Java приведена в переводе:

Советы и приемы

Чтобы минимизировать объем памяти, максимально ограничьте область видимости переменных. Помните, что каждый раз, когда выскакивает верхняя область видимости из стека, ссылки из этой области теряются, и это может сделать объекты пригодными для сбора мусора.

Явно устанавливайте в null устаревшие ссылки. Это сделает объекты, на которые ссылаются, подходящими для сбора мусора.

Избегайте финализаторов (finalizer). Они замедляют процесс и ничего не гарантируют. Фантомные ссылки предпочтительны для работы по очистке памяти.

JVisualVM также имеет функцию создания дампа кучи в определенный момент, чтобы вы могли анализировать для каждого класса, сколько памяти он занимает.

Настройте JVM в соответствии с требованиями вашего приложения. Явно укажите размер кучи для JVM при запуске приложения. Процесс выделения памяти также является дорогостоящим, поэтому выделите разумный начальный и максимальный объем памяти для кучи. Если вы знаете его, то не имеет смысла начинать с небольшого начального размера кучи с самого начала, JVM расширит это пространство памяти. Указание параметров памяти выполняется с помощью следующих параметров:

Если приложение Java выдает ошибку OutOfMemoryError и вам нужна дополнительная информация для обнаружения утечки, запустите процесс с –XX:HeapDumpOnOutOfMemory параметром, который создаст файл дампа кучи, когда эта ошибка произойдет в следующий раз.

Заключение

Источник

Переменные-ссылки в Java

1. Переменные-ссылки

В языке Java переменные могут быть двух видов: переменные примитивного типа и все остальные. Вот про «все остальные» мы сейчас и поговорим.

На самом деле правильнее будет сказать, что есть переменные примитивного типа (primitive type variables) и ссылочные переменные (reference variables). Так что же это такое, эти ссылочные переменные?

В отличие от примитивных типов, которые позволяют хранить значения прямо внутри переменных, переменные ссылочных типов хранят ссылки на объекты. Т.е. где-то в памяти существует некий объект, а в переменной-ссылке просто хранится адрес этого объекта в памяти (ссылка).

И массив, и строка являются объектами, которые хранятся где-то в памяти. Переменные типа String и переменные типа массив хранят только ссылки на объекты.

Переменные int a, int b и double d — примитивные и хранят значение внутри себя.

Переменная String str — ссылочная и хранит адрес (ссылку) объекта типа String в памяти.

2. Суть ссылок

В чем принципиальное отличие переменных-ссылок от примитивных переменных?

Примитивная переменная — как коробка: в ней можно хранить какое-нибудь значение. Переменная-ссылка больше похожа на листок бумаги с телефонным номером на нем.

Машина vs ключи от машины

Представьте, что вы решили подарить другу на день рождения машину. Вы же не будете заворачивать ее в коробку и нести с собой: машина для этого слишком большая.

Гораздо удобнее взять с собой только ключи от машины и коробку, достаточно вместительную для них. А ваш друг и так все поймет, когда достанет из коробки ключи. Нет нужды нести с собой всю машину, когда можно просто передать ключи.

Человек vs его телефонный номер

Или еще один вариант: человек и его телефонный номер. Телефонный номер — не сам человек, но номер телефона можно использовать, чтобы звонить ему, спрашивать у него какую-то информацию, давать команды.

Ссылка тоже используется для взаимодействия с объектом. Все объекты взаимодействуют друг с другом при помощи ссылок. Вместо того, чтобы «обмениваться людьми», достаточно обменяться телефонными номерами.

При присваивании значения в примитивную переменную, его значение копируется (дублируется). При присваивании же значения ссылочной переменной копируется только адрес объекта («телефонный номер»), сам же объект при этом не копируется.

Ссылка даёт ещё одно преимущество: можно передать ссылку на объект в какой-нибудь метод, и этот метод будет в состоянии модифицировать (изменять) наш объект, используя ссылку на него, вызывая его методы и обращаясь к данным внутри объекта.

3. Присваивание ссылок

При присваивании ссылочных переменных происходит просто присваивание адреса объекта в памяти. Сами объекты при этом не появляются и не исчезают.

Такой подход позволяет избежать копирования больших объемов памяти. Если куда-то нужно передать очень большой объект, мы просто передадим в этот метод ссылку на объект и все. Ссылка занимает гораздо меньше места.

Размер всех переменных-ссылок (независимо от типа) одинаков и составляет 4 байта (как тип int). Но! Если ваше приложение запущено на 64-х разрядной Java-машине, размер всех ссылок будет 8 байт (64 бита).

Ссылки при этом можно только присваивать друг другу. Вы не можете менять ссылки или присваивать им произвольные значения:

4. Пустая ссылка — null

А что хранит переменная-ссылка, если ей еще ничего не присвоили?

Локальные переменные без значения считаются неинициализированными как для примитивных типов, так и для типов-ссылок.

Если переменная хранит ссылку на какой-то объект, а вы хотите стереть значение переменной, просто присвойте ей ссылку null.

5. Передача ссылок в методы

Вот как будет выглядеть ситуация в памяти перед вызовом метода fill :

Вот как будет выглядеть ситуация во время работы метода fill :

Переменные data и array ссылаются (хранят ссылки) на один и тот же массив-контейнер в памяти.

Фактически никакого дублирования объектов не происходит — копируются только ссылки.

Источник