[GR-44830] Revert "Avoid using the SafepointManager if there is only the root and reference processing threads"

* This reverts commit 9b08749.
* There is no need for this anymore since TruffleSafepoint is fast and
  needs no invalidation (unlike SafepointManager).
* Manual Thread#interrupt() can be lost with TruffleSafepoint (GR-44830),
  due to `TruffleSafepoint.Interrupter#THREAD_INTERRUPT` resetting the
  interrupt flag if a safepoint was run while inside setBlockedWithException().
* With this the 2 usages left of Thread#interrupt() in truffleruby are
  only there to set the interrupt flag after `catch (InterruptedException e)`.

Author: eregon

src/main/java/org/truffleruby/core/ReferenceProcessingService.java

@@ -17,7 +17,6 @@
 import org.truffleruby.annotations.SuppressFBWarnings;
 import org.truffleruby.core.thread.RubyThread;
 import org.truffleruby.core.thread.ThreadManager;
-import org.truffleruby.language.control.KillException;
 import org.truffleruby.language.control.RaiseException;
 
 import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary;
@@ -73,7 +72,6 @@ public ReferenceProcessingService<R, T> service() {
     public static class ReferenceProcessor {
         protected final ReferenceQueue<Object> processingQueue = new ReferenceQueue<>();
 
-        private volatile boolean shutdown = false;
         protected RubyThread processingThread;
         protected final RubyContext context;
 
@@ -121,40 +119,13 @@ protected void createProcessingThread(ReferenceProcessingService<?, ?> service)
 
             threadManager.initialize(newThread, DummyNode.INSTANCE, THREAD_NAME, sharingReason, () -> {
                 while (true) {
-                    final PhantomProcessingReference<?, ?> reference = threadManager
-                            .runUntilResult(DummyNode.INSTANCE, () -> {
-                                try {
-                                    return (PhantomProcessingReference<?, ?>) processingQueue.remove();
-                                } catch (InterruptedException interrupted) {
-                                    if (shutdown) {
-                                        throw new KillException(DummyNode.INSTANCE);
-                                    } else {
-                                        throw interrupted;
-                                    }
-                                }
-                            });
+                    final PhantomProcessingReference<?, ?> reference = threadManager.runUntilResult(DummyNode.INSTANCE,
+                            () -> (PhantomProcessingReference<?, ?>) processingQueue.remove());
                     reference.service().processReference(context, language, reference);
                 }
             });
         }
 
-        public boolean shutdownProcessingThread() {
-            final Thread javaThread = processingThread == null ? null : processingThread.thread;
-            if (javaThread == null) {
-                return false;
-            }
-
-            shutdown = true;
-            javaThread.interrupt();
-
-            context.getThreadManager().runUntilResultKeepStatus(DummyNode.INSTANCE, t -> t.join(1000), javaThread);
-            return true;
-        }
-
-        public RubyThread getProcessingThread() {
-            return processingThread;
-        }
-
         @TruffleBoundary
         protected final void drainReferenceQueues() {
             final RubyLanguage language = context.getLanguageSlow();

src/main/java/org/truffleruby/core/thread/ThreadManager.java

@@ -662,33 +662,10 @@ public void checkNoRunningThreads() {
     @TruffleBoundary
     public void killAndWaitOtherThreads() {
         // Kill all Ruby Threads and Fibers
-
-        // The logic below avoids using the SafepointManager if there is
-        // only the current thread and the reference processing thread.
-        final RubyThread currentThread = language.getCurrentThread();
-        boolean otherThreads = false;
-        RubyThread referenceProcessingThread = null;
-        for (RubyThread thread : runningRubyThreads) {
-            if (thread == currentThread) {
-                // no need to kill the current thread
-            } else if (thread == context.getReferenceProcessor().getProcessingThread()) {
-                referenceProcessingThread = thread;
-            } else {
-                otherThreads = true;
-                break;
-            }
-        }
-
-        if (!otherThreads && referenceProcessingThread != null) {
-            if (!context.getReferenceProcessor().shutdownProcessingThread()) {
-                otherThreads = true;
-            }
-        }
-
-        if (otherThreads) {
+        if (runningRubyThreads.size() > 1) {
             doKillOtherThreads();
         }
-        context.fiberManager.killOtherFibers(currentThread);
+        context.fiberManager.killOtherFibers(language.getCurrentThread());
 
         // Wait and join all Java threads we created
         for (Thread thread : rubyManagedThreads) {