[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"question-jvm-chto-takoe-strong-weak-soft-i-phantom-ssylki-v-java":3},{"id":4,"slug":5,"topicId":6,"topicSlug":7,"topicName":8,"topicEmoji":9,"question":10,"answer":11,"codeLang":12,"codeSrc":12,"important":12,"commonMistakes":12,"modernUsage":12,"difficulty":13,"tags":14,"related":18,"progress":19,"seo":20},1220,"chto-takoe-strong-weak-soft-i-phantom-ssylki-v-java",38,"jvm","JVM","⚙️","Что такое Strong, Weak, Soft и Phantom ссылки в Java","Типы ссылок в Java — это механизм из пакета `java.lang.ref`, определяющий, как сборщик мусора обрабатывает объект. Существует четыре уровня силы ссылок: Strong, Soft, Weak и Phantom. Чем слабее ссылка, тем легче GC собирает объект.\n\n> Аналогия из жизни: представьте, что вы держите предмет (Strong — крепко в руке, не отдадите), лежит в кармане (Soft — отдадите, только если руки заняты и нужно место), прикреплён стикером (Weak — слетит при любом дуновении ветра), или вы видите только след от предмета (Phantom — предмет уже забрали, но вы можете узнать, что его забрали).\n\n### Сравнительная таблица\n\n| Тип | `get()` | Когда собирается | ReferenceQueue | Применение |\n|---|---|---|---|---|\n| Strong | — | Никогда (пока есть ссылка) | — | Обычный код |\n| Soft | Объект или null | При нехватке памяти | Опционально | Кэши |\n| Weak | Объект или null | При ближайшем GC | Опционально | WeakHashMap, listeners |\n| Phantom | Всегда null | После finalization | Обязательно | Очистка ресурсов, замена finalize |\n\n### Strong Reference (сильная ссылка)\n\nОбычная ссылка в Java. Объект не будет собран GC, пока на него существует хотя бы одна strong reference.\n\n```java\nObject obj = new Object(); \u002F\u002F strong reference\nobj = null;                \u002F\u002F теперь объект доступен для GC\n```\n\n### Soft Reference (мягкая ссылка)\n\nОбъект будет собран GC только при нехватке памяти (перед выбросом `OutOfMemoryError`). Идеально подходит для кэшей.\n\n```java\nSoftReference\u003CBufferedImage> ref = new SoftReference\u003C>(loadImage(path));\nBufferedImage image = ref.get(); \u002F\u002F объект или null, если GC собрал\n```\n\n### Weak Reference (слабая ссылка)\n\nОбъект будет собран при ближайшем цикле GC, если нет strong или soft ссылок. Используется для ассоциативных структур.\n\n```java\nWeakReference\u003CExpensiveObject> weakRef = new WeakReference\u003C>(new ExpensiveObject());\nExpensiveObject obj = weakRef.get();\nif (obj != null) {\n    obj.doSomething();\n}\n```\n\n`WeakHashMap` — готовая реализация Map, использующая weak references для ключей. Записи автоматически удаляются, когда на ключ нет strong references.\n\n### Phantom Reference (фантомная ссылка)\n\nСамая слабая ссылка. `get()` всегда возвращает `null`. Используется вместе с `ReferenceQueue` для получения уведомления о том, что объект финализирован. Основное применение — очистка внешних ресурсов.\n\n```java\nReferenceQueue\u003CObject> queue = new ReferenceQueue\u003C>();\nPhantomReference\u003CObject> phantomRef = new PhantomReference\u003C>(resource, queue);\n\u002F\u002F phantomRef.get() всегда null\n\u002F\u002F После GC: phantomRef помещается в queue для обработки\n```\n\nС Java 9 механизм `Cleaner` (основанный на PhantomReference) полностью заменил deprecated `finalize()`:\n\n\u003Cdetails>\n\u003Csummary>Пример использования Cleaner\u003C\u002Fsummary>\n\n```java\npublic class NativeResource implements AutoCloseable {\n    private static final Cleaner CLEANER = Cleaner.create();\n\n    private final long nativePtr;\n    private final Cleaner.Cleanable cleanable;\n\n    public NativeResource() {\n        this.nativePtr = allocateNative();\n        \u002F\u002F CleanAction НЕ должен ссылаться на NativeResource\n        this.cleanable = CLEANER.register(this, new CleanAction(nativePtr));\n    }\n\n    @Override\n    public void close() {\n        cleanable.clean(); \u002F\u002F явная очистка\n    }\n\n    private static class CleanAction implements Runnable {\n        private final long ptr;\n        CleanAction(long ptr) { this.ptr = ptr; }\n\n        @Override\n        public void run() {\n            freeNative(ptr);\n        }\n    }\n}\n```\n\n\u003C\u002Fdetails>\n\n### Порядок сборки GC\n\n```\nStrong -> Soft -> Weak -> Phantom -> Сборка памяти\n\n1. Есть Strong reference -> объект НЕ собирается\n2. Только Soft references -> собирается при нехватке памяти\n3. Только Weak references -> собирается при ближайшем GC\n4. Только Phantom references -> объект финализирован,\n   PhantomReference помещается в ReferenceQueue\n```\n\n### Частые ошибки\n\n- Использование `SoftReference` вместо `WeakReference` (или наоборот) — разное поведение GC\n- Хранение strong reference на объект рядом с weak\u002Fsoft reference — GC не соберёт объект\n- Забывают проверять `ref.get() != null` — объект может быть собран в любой момент\n- Использование `PhantomReference` без `ReferenceQueue` — бессмысленно\n- Действие очистки в `Cleaner` ссылается на очищаемый объект — создаёт strong reference, объект никогда не будет собран\n\n> **На собеседовании:** назовите четыре типа ссылок и когда GC собирает каждый. Ключевые примеры: Soft — для кэшей, Weak — для WeakHashMap и listeners, Phantom — замена finalize через Cleaner. Частая ловушка — вопрос о `PhantomReference.get()` (всегда null) и о том, зачем нужен ReferenceQueue.","","middle",[7,15,16,17],"core","memory","gc",[],null,{"title":21,"description":22,"ogTitle":23,"ogDescription":24,"keywords":25,"schemaAnswer":36,"featuredSnippetReady":37},"Что такое Strong, Weak, Soft и Phantom ссылки в Java — Gymterview","Типы ссылок в Java: Strong, Soft (кэши), Weak (WeakHashMap), Phantom (Cleaner). Порядок сборки GC, ReferenceQueue, замена finalize. Сравнительная таблица.","Strong, Weak, Soft и Phantom ссылки в Java — Gymterview","Четыре типа ссылок: Strong (обычная), Soft (кэши), Weak (WeakHashMap), Phantom (замена finalize). Порядок сборки GC.",[26,27,28,29,30,31,32,33,34,35],"Strong reference","Soft reference","Weak reference","Phantom reference","WeakHashMap","Cleaner","ReferenceQueue","GC","Java","собеседование","Четыре типа ссылок из java.lang.ref: Strong (обычная, объект не собирается), Soft (собирается при нехватке памяти — для кэшей), Weak (собирается при ближайшем GC — WeakHashMap, listeners), Phantom (get() всегда null, уведомляет через ReferenceQueue о финализации — Cleaner). Порядок силы: Strong > Soft > Weak > Phantom. Cleaner (Java 9+) заменил deprecated finalize().",true]