| /* |
| * 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(); |
| } |
| |
| } |