База знанияИзпитен център
BGБългарски
Избери език13

CKTIS / Java

Жизнен цикъл на слабите, меките и фантомните референции в Java

Научи кога референцията връща сочения обект, какво влиза в опашката и как `reachabilityFence` запазва обекта силно достижим.

Версия: Java SE 21

Синтаксис

Java SE 21 · java.lang.ref (module java.base)
new WeakReference<T>(referent)
new WeakReference<T>(referent, queue)
new SoftReference<T>(referent)
new SoftReference<T>(referent, queue)
new PhantomReference<T>(referent, queue)
new ReferenceQueue<T>()

// Registered constructors accept ReferenceQueue<? super T>.
T value = reference.get();
reference.clear();
boolean added = reference.enqueue();
Reference.reachabilityFence(referent);

// For a queue of type ReferenceQueue<T>:
Reference<? extends T> ready = queue.poll();
Reference<? extends T> next = queue.remove(); // throws InterruptedException
Reference<? extends T> timed = queue.remove(timeoutMillis); // long; throws InterruptedException

В java.lang.ref (модул java.base) референцията и соченият от нея обект са два различни обекта. Когато механизмът за събиране на памет (GC) установи, че даден обект е слабо достижим, тоест не е нито силно, нито меко достижим, но до него може да се стигне през слаба референция, той изчиства неговите WeakReference. При нужда от памет GC може по своя преценка да изчисти SoftReference към меко достижими обекти. Виртуалната машина гарантира, че всички такива меки референции са изчистени, преди да хвърли OutOfMemoryError, но иначе не определя момент или ред. PhantomReference служи за известия, свързани с почистване: GC я изчиства при установяване на фантомна достижимост, а нейният get() винаги връща null.

Конструкторите за слаби и меки референции приемат само сочения обект или обекта и ReferenceQueue<? super T>. Фантомният конструктор винаги изисква аргумент за опашката. Подаването на null вместо опашка означава, че няма регистрация. При слаба или мека референция get() връща сочения обект или null, ако липсва, например след изчистване. Прочети резултата веднъж, провери дали е различен от null и използвай същата локална променлива. clear() прекъсва връзката, но само по себе си не добавя референцията в опашката и не освобождава сочения обект. enqueue() изчиства референцията и изрично се опитва да я добави в опашката, в която е регистрирана; при успех връща true.

Статичният метод Reference.reachabilityFence(obj) запазва obj силно достижим до края на извикването, дори кодът вече да не го използва пряко. Постави извикването в блок finally след операцията, която изисква обектът да остане жив, за да се изпълни и при изключение. Подай самия обект, а не слабата, меката или фантомната референция към него. Методът не задейства GC или финализация; при null няма ефект.

От ReferenceQueue<T> се извлича Reference<? extends T>, а не соченият от нея обект. poll() премахва и връща налична референция или веднага връща null. remove() изчаква без ограничение. При положителен срок в милисекунди remove(long timeout) връща null след изтичането му, без гаранции за работа в реално време. 0 означава неограничено чакане, а отрицателна стойност води до IllegalArgumentException. И двете претоварвания на remove хвърлят InterruptedException, ако чакането бъде прекъснато.

GC добавя регистрираните референции в опашката при изчистване или по-късно; моментът е непредвидим. Празен резултат от poll() не означава, че соченият обект е още жив. Пази силна референция към всеки регистриран референтен обект, докато ти трябва известието: регистрацията сама по себе си не го поддържа жив. Не разчитай на известията от GC за своевременно затваряне на ресурси.

Примери

import java.lang.ref.PhantomReference;
import java.lang.ref.Reference;
import java.lang.ref.ReferenceQueue;
import java.lang.ref.SoftReference;
import java.lang.ref.WeakReference;

public class ReferenceLifecycle {
    public static void main(String[] args) throws InterruptedException {
        Object target = new Object();
        ReferenceQueue<Object> queue = new ReferenceQueue<>();
        WeakReference<Object> weak = new WeakReference<>(target, queue);
        SoftReference<Object> soft = new SoftReference<>(target);
        PhantomReference<Object> phantom = new PhantomReference<>(target, queue);

        try {
            System.out.println("weak.get() == target: " + (weak.get() == target));
            System.out.println("soft.get() == target: " + (soft.get() == target));
            weak.clear();
            soft.clear();
            System.out.println("weak.get() == null: " + (weak.get() == null));
            System.out.println("soft.get() == null: " + (soft.get() == null));
            System.out.println("poll() after clear: " + queue.poll());

            if (!weak.enqueue()) {
                throw new IllegalStateException("Expected weak reference to be enqueued");
            }
            System.out.println("remove(1000) == weak: " + (queue.remove(1000) == weak));

            System.out.println("phantom.get() == null: " + (phantom.get() == null));
            if (!phantom.enqueue()) {
                throw new IllegalStateException("Expected phantom reference to be enqueued");
            }
            System.out.println("remove() == phantom: " + (queue.remove() == phantom));
        } finally {
            Reference.reachabilityFence(target);
        }
    }
}

Резултат

weak.get() == target: true
soft.get() == target: true
weak.get() == null: true
soft.get() == null: true
poll() after clear: null
remove(1000) == weak: true
phantom.get() == null: true
remove() == phantom: true

Бариерата запазва `target` силно достижим, а `enqueue()` изрично добавя елемент преди всяко `remove`. Примерът показва разликата между изчистване и добавяне в опашка, а не кога се намесва GC или как изтича срокът.

Свързани уроци

  • Java · Урок 45 · Напреднало · Версия: 2

Източници