Can object be garbage collected between two subsequent calls to WeakReference.get()?

Question

I sometimes see the code of this kind in some library APIs and just in someone's code:

class SomeClass {

    private WeakReference<SomeObject> objectWeakReference; // initialized elsewhere

    public boolean isObjectAttached() {
        return objectWeakReference.get() != null;
    }

    public SomeObject getObject() {
        return objectWeakReference.get();
    }

}

and

public void checkAndGetWeakReference() {
    SomeClass someClass = new SomeClass();
    if (someClass.isObjectAttached()) {
        someClass.getObject().doSomethingDirectlyOnReturnedObject(); // can the returned reference be null here ?
    }
}

And I'm always worried if there could be NullPointerException once in a blue moon, assuming there are no strong reference to the underlying object at this point.

I don't really know when exactly Garbage Collector can start deleting objects from memory and how does it correlate with the basic thread flow.

It would be nice if someone can shed the light on this particular subject and/or provide some information about the topic.

P.S. I would personally get reference only once and assign it to strong reference. The point of the question is to get some proof the code above is wrong.

Answer 1

The whole point of the WeakReference (and SoftReference as well) is that the referred object may be gc'd at any time no strong reference to the object exists.

Since there exists no strong reference when isObjectAttached() returns, yes it can be garbage collected before it actually gets to execute getObject(). The whole idom is faulty for this use case.

The only safe way is to first get the reference (e.g. to a local variable) and then check it against null. The object can then not be garbage collected in that case, because a local variable is a strong reference.