SoftReference and WeakReference clearing

Question

According to the javadoc of SoftReference:
http://java.sun.com/javase/6/docs/api/java/lang/ref/SoftReference.html:
Suppose that the garbage collector determines at a certain point in time that an object is softly reachable. At that time it may choose to clear atomically all soft references to that object and all soft references to any other softly-reachable objects from which that object is reachable through a chain of strong references.So all SoftReferences will be cleared atomically. Will WeakReferences be cleared at the same time atomically with the clearing of the SoftReferences?
In other words, is it possible that WeakReference.get can return a hard reference after the soft reference has been cleared by the garbage collector?
Cheers,
Dave.

Answer 1

Here is my test application which shows it works the way I was expecting, both references get cleared at the same time:
a_garbage_b_not: 0
b_garbage_a_not: 0
both_garbage: 2000However, I'm not sure this is conclusive enough and would please like confirmation and/or a link to some garbage collection documentation that states this is how it works.
public class Main {
    public static void main(String[] args) {
        int a_garbage_b_not = 0;
        int b_garbage_a_not = 0;
        int both_garbage = 0;
        int idx = 0;
        while (idx < 1000000)
            int jdx = 0;
            while (jdx++ < 100)
                idx++;
                ObjectA obj_a = new ObjectA(new ObjectB());
                WeakReference weak_a = new WeakReference(obj_a);
                WeakReference weak_b = new WeakReference(obj_a.obj_b);
                obj_a = null;
                boolean a_garbaged = false;
                boolean b_garbaged = false;
                int loop = 0;
                ArrayList rubbish = new ArrayList();
                while (!a_garbaged && !b_garbaged)
                    rubbish.add(new Object());
                    loop++;
                    a_garbaged = weak_a.get() == null;
                    b_garbaged = weak_b.get() == null;
                rubbish = null;
                if (a_garbaged && b_garbaged) {
                    System.out.println(idx + ": both_garbage, loops: " + loop);
                    both_garbage++;
                else if (a_garbaged && !b_garbaged) {
                    System.out.println(idx + ": a_garbage_b_not, loops: " + loop);
                    a_garbage_b_not++;
                else if (!a_garbaged && b_garbaged) {
                    System.out.println(idx + ": b_garbage_a_not, loops: " + loop);
                    b_garbage_a_not++;
            System.out.println("a_garbage_b_not: " + a_garbage_b_not);
            System.out.println("b_garbage_a_not: " + b_garbage_a_not);
            System.out.println("both_garbage:    " + both_garbage);
    private static class ObjectA
        private final ObjectB obj_b;
        private ObjectA(ObjectB obj_b)
            this.obj_b = obj_b;
    private static class ObjectB
}Cheers,
Dave.