* gnu/gcj/runtime/natFinalizerThread.cc: New file.

	* java/lang/natRuntime.cc: Include FinalizerThread.h.
	(runFinalization): Call finalizerReady.
	* nogc.cc (_Jv_GCInitializeFinalizers): New function.
	* prims.cc: Include VirtualMachineError.h, FinalizerThread.h.
	(_Jv_CreateJavaVM): Start the finalizer thread.
	* no-threads.cc: Include InternalError.h.
	(_Jv_ThreadStart): Throw InternalError.
	(_Jv_ThreadInitData): Don't throw error if this is not the first
	thread.
	* Makefile.in: Rebuilt.
	* Makefile.am (ordinary_java_source_files): Added
	FinalizerThread.java.
	(nat_source_files): Added natFinalizerThread.cc.
	* include/jvm.h (_Jv_GCInitializeFinalizers): Declare.
	* boehm.cc (_Jv_GCInitializeFinalizers): New function.
	* gnu/gcj/runtime/FirstThread.java (run): Start finalizer thread.
	* gnu/gcj/runtime/FinalizerThread.java: New file.


git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@46163 138bc75d-0d04-0410-961f-82ee72b054a4

1 files changed, 73 insertions, 0 deletions

diff --git a/libjava/gnu/gcj/runtime/FinalizerThread.java b/libjava/gnu/gcj/runtime/FinalizerThread.java
new file mode 100644
index 00000000000..e333d7a41c7
--- /dev/null
+++ b/libjava/gnu/gcj/runtime/FinalizerThread.java
@@ -0,0 +1,73 @@
+// FinalizerThread.java -- Thread in which finalizers are run.
+
+/* Copyright (C) 2001  Free Software Foundation
+
+   This file is part of libgcj.
+
+This software is copyrighted work licensed under the terms of the
+Libgcj License.  Please consult the file "LIBGCJ_LICENSE" for
+details.  */
+
+package gnu.gcj.runtime;
+
+/**
+ * @author Tom Tromey <tromey@redhat.com>
+ * @date October 3, 2001
+ */
+public final class FinalizerThread extends Thread
+{
+  // Finalizers must be run in a thread with no Java-visible locks
+  // held.  This qualifies because we don't make the lock visible.
+  private static final Object lock = new Object ();
+
+  // This is true if the finalizer thread started successfully.  It
+  // might be false if, for instance, there are no threads on the
+  // current platform.  In this situation we run finalizers in the
+  // caller's thread.
+  private static boolean thread_started = false;
+
+  public FinalizerThread ()
+  {
+    super ("LibgcjInternalFinalizerThread");
+    setDaemon (true);
+  }
+
+  // This is called by the runtime when a finalizer is ready to be
+  // run.  It simply wakes up the finalizer thread.
+  public static void finalizerReady ()
+  {
+    synchronized (lock)
+      {
+	if (! thread_started)
+	  runFinalizers ();
+	else
+	  lock.notify ();
+      }
+  }
+
+  // Actually run the finalizers.
+  private static native void runFinalizers ();
+
+  public void run ()
+  {
+    // Wait on a lock.  Whenever we wake up, try to invoke the
+    // finalizers.
+    synchronized (lock)
+      {
+	thread_started = true;
+	while (true)
+	  {
+	    try
+	      {
+		lock.wait ();
+	      }
+	    catch (InterruptedException _)
+	      {
+		// Just ignore it.  It doesn't hurt to run finalizers
+		// when none are pending.
+	      }
+	    runFinalizers ();
+	  }
+      }
+  }
+}