test/jdk/java/lang/ref/Basic.java

/*
 * Copyright (c) 1997, 2024, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

/* @test
 * @summary Basic functional test of reference objects
 * @author Mark Reinhold
 */


import java.lang.ref.*;
import java.util.Vector;


public class Basic {

    static ReferenceQueue q = new ReferenceQueue();
    static ReferenceQueue q2 = new ReferenceQueue();
    static Reference rw, rw2, rp, rp2;
    static Vector keep = new Vector();
    static boolean finalized = false;

    public static class ClearFinalizerThread {
        protected void finalize() {
            System.err.println("Cleared finalizer thread");
        }
    };

    protected void finalize() {
        System.err.println("Finalized " + this);
        Basic.finalized = true;
    }

    public static class Sub { };

    Object sub = new Sub();

    static void fork(Runnable proc) throws InterruptedException {
        Thread t = new Thread(proc);
        t.start();
        t.join();
    }

    static void showReferences() throws InterruptedException {
        fork(new Runnable() {
            public void run() {
                System.err.println("References: W " + rw.get()
                                   + ", W2 " + rw2.get()
                                   + ", P " + rp.get()
                                   + ", P2 " + rp2.get());
            }
        });
    }

    static void createNoise() throws InterruptedException {
        fork(new Runnable() {
            public void run() {
                keep.addElement(new PhantomReference(new Object(), q2));
            }
        });
    }


    public static void main(String[] args) throws Exception {

        fork(new Runnable() {
            public void run() {
                Basic s = new Basic();
                rw = new WeakReference(s, q);
                rw2 = new WeakReference(s);
                rp = new PhantomReference(s, q);
                rp2 = new PhantomReference(s.sub, q);
                s = null;
            }
        });

        showReferences();

        int ndq = 0;
        boolean prevFinalized = false;
    outer:
        for (int i = 1;; i++) {
            Reference r;

            createNoise();
            System.err.println("GC " + i);
            Thread.sleep(10);
            System.gc();
            System.runFinalization();

            showReferences();
            while ((r = q2.poll()) != null) {
                System.err.println("Noise " + r);
            }

            /* Cause a dummy object to be finalized, since the finalizer thread
               might retain a reference to the Basic instance after it's been
               finalized (this happens with java_g) */
            if (Basic.finalized && !prevFinalized) {
                fork(new Runnable() {
                    public void run() {
                        new ClearFinalizerThread();
                    }});
                prevFinalized = true;
            }

            while ((r = q.poll()) != null) {
                ndq++;
                if (r != null) {
                    System.err.println("Dequeued " + r);
                    if (ndq == 3) break outer;
                }
            }

            if (i >= 10) break;

        }

        if (ndq != 3) {
            throw new Exception("Expected to dequeue 3 reference objects,"
                                + " but only got " + ndq);
        }

        if (! Basic.finalized) {
            throw new Exception("Test object not finalized");
        }

    }

}