8187443: Forest Consolidation: Move files to unified layout

Reviewed-by: darcy, ihse

src/java.base/share/classes/java/lang/ref/Finalizer.java

@@ -0,0 +1,236 @@
+/*
+ * Copyright (c) 1997, 2015, 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.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * 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.
+ */
+
+package java.lang.ref;
+
+import java.security.PrivilegedAction;
+import java.security.AccessController;
+import jdk.internal.misc.JavaLangAccess;
+import jdk.internal.misc.SharedSecrets;
+import jdk.internal.misc.VM;
+
+final class Finalizer extends FinalReference<Object> { /* Package-private; must be in
+                                                          same package as the Reference
+                                                          class */
+
+    private static ReferenceQueue<Object> queue = new ReferenceQueue<>();
+    private static Finalizer unfinalized = null;
+    private static final Object lock = new Object();
+
+    private Finalizer
+        next = null,
+        prev = null;
+
+    private boolean hasBeenFinalized() {
+        return (next == this);
+    }
+
+    private void add() {
+        synchronized (lock) {
+            if (unfinalized != null) {
+                this.next = unfinalized;
+                unfinalized.prev = this;
+            }
+            unfinalized = this;
+        }
+    }
+
+    private void remove() {
+        synchronized (lock) {
+            if (unfinalized == this) {
+                if (this.next != null) {
+                    unfinalized = this.next;
+                } else {
+                    unfinalized = this.prev;
+                }
+            }
+            if (this.next != null) {
+                this.next.prev = this.prev;
+            }
+            if (this.prev != null) {
+                this.prev.next = this.next;
+            }
+            this.next = this;   /* Indicates that this has been finalized */
+            this.prev = this;
+        }
+    }
+
+    private Finalizer(Object finalizee) {
+        super(finalizee, queue);
+        add();
+    }
+
+    static ReferenceQueue<Object> getQueue() {
+        return queue;
+    }
+
+    /* Invoked by VM */
+    static void register(Object finalizee) {
+        new Finalizer(finalizee);
+    }
+
+    private void runFinalizer(JavaLangAccess jla) {
+        synchronized (this) {
+            if (hasBeenFinalized()) return;
+            remove();
+        }
+        try {
+            Object finalizee = this.get();
+            if (finalizee != null && !(finalizee instanceof java.lang.Enum)) {
+                jla.invokeFinalize(finalizee);
+
+                /* Clear stack slot containing this variable, to decrease
+                   the chances of false retention with a conservative GC */
+                finalizee = null;
+            }
+        } catch (Throwable x) { }
+        super.clear();
+    }
+
+    /* Create a privileged secondary finalizer thread in the system thread
+       group for the given Runnable, and wait for it to complete.
+
+       This method is used by both runFinalization and runFinalizersOnExit.
+       The former method invokes all pending finalizers, while the latter
+       invokes all uninvoked finalizers if on-exit finalization has been
+       enabled.
+
+       These two methods could have been implemented by offloading their work
+       to the regular finalizer thread and waiting for that thread to finish.
+       The advantage of creating a fresh thread, however, is that it insulates
+       invokers of these methods from a stalled or deadlocked finalizer thread.
+     */
+    private static void forkSecondaryFinalizer(final Runnable proc) {
+        AccessController.doPrivileged(
+            new PrivilegedAction<>() {
+                public Void run() {
+                    ThreadGroup tg = Thread.currentThread().getThreadGroup();
+                    for (ThreadGroup tgn = tg;
+                         tgn != null;
+                         tg = tgn, tgn = tg.getParent());
+                    Thread sft = new Thread(tg, proc, "Secondary finalizer", 0, false);
+                    sft.start();
+                    try {
+                        sft.join();
+                    } catch (InterruptedException x) {
+                        Thread.currentThread().interrupt();
+                    }
+                    return null;
+                }});
+    }
+
+    /* Called by Runtime.runFinalization() */
+    static void runFinalization() {
+        if (VM.initLevel() == 0) {
+            return;
+        }
+
+        forkSecondaryFinalizer(new Runnable() {
+            private volatile boolean running;
+            public void run() {
+                // in case of recursive call to run()
+                if (running)
+                    return;
+                final JavaLangAccess jla = SharedSecrets.getJavaLangAccess();
+                running = true;
+                for (;;) {
+                    Finalizer f = (Finalizer)queue.poll();
+                    if (f == null) break;
+                    f.runFinalizer(jla);
+                }
+            }
+        });
+    }
+
+    /* Invoked by java.lang.Shutdown */
+    static void runAllFinalizers() {
+        if (VM.initLevel() == 0) {
+            return;
+        }
+
+        forkSecondaryFinalizer(new Runnable() {
+            private volatile boolean running;
+            public void run() {
+                // in case of recursive call to run()
+                if (running)
+                    return;
+                final JavaLangAccess jla = SharedSecrets.getJavaLangAccess();
+                running = true;
+                for (;;) {
+                    Finalizer f;
+                    synchronized (lock) {
+                        f = unfinalized;
+                        if (f == null) break;
+                        unfinalized = f.next;
+                    }
+                    f.runFinalizer(jla);
+                }}});
+    }
+
+    private static class FinalizerThread extends Thread {
+        private volatile boolean running;
+        FinalizerThread(ThreadGroup g) {
+            super(g, null, "Finalizer", 0, false);
+        }
+        public void run() {
+            // in case of recursive call to run()
+            if (running)
+                return;
+
+            // Finalizer thread starts before System.initializeSystemClass
+            // is called.  Wait until JavaLangAccess is available
+            while (VM.initLevel() == 0) {
+                // delay until VM completes initialization
+                try {
+                    VM.awaitInitLevel(1);
+                } catch (InterruptedException x) {
+                    // ignore and continue
+                }
+            }
+            final JavaLangAccess jla = SharedSecrets.getJavaLangAccess();
+            running = true;
+            for (;;) {
+                try {
+                    Finalizer f = (Finalizer)queue.remove();
+                    f.runFinalizer(jla);
+                } catch (InterruptedException x) {
+                    // ignore and continue
+                }
+            }
+        }
+    }
+
+    static {
+        ThreadGroup tg = Thread.currentThread().getThreadGroup();
+        for (ThreadGroup tgn = tg;
+             tgn != null;
+             tg = tgn, tgn = tg.getParent());
+        Thread finalizer = new FinalizerThread(tg);
+        finalizer.setPriority(Thread.MAX_PRIORITY - 2);
+        finalizer.setDaemon(true);
+        finalizer.start();
+    }
+
+}