summaryrefslogtreecommitdiffstats
path: root/qadevOOo/runner/util/WaitUnreachable.java
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 09:06:44 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 09:06:44 +0000
commited5640d8b587fbcfed7dd7967f3de04b37a76f26 (patch)
tree7a5f7c6c9d02226d7471cb3cc8fbbf631b415303 /qadevOOo/runner/util/WaitUnreachable.java
parentInitial commit. (diff)
downloadlibreoffice-ed5640d8b587fbcfed7dd7967f3de04b37a76f26.tar.xz
libreoffice-ed5640d8b587fbcfed7dd7967f3de04b37a76f26.zip
Adding upstream version 4:7.4.7.upstream/4%7.4.7upstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'qadevOOo/runner/util/WaitUnreachable.java')
-rw-r--r--qadevOOo/runner/util/WaitUnreachable.java119
1 files changed, 119 insertions, 0 deletions
diff --git a/qadevOOo/runner/util/WaitUnreachable.java b/qadevOOo/runner/util/WaitUnreachable.java
new file mode 100644
index 000000000..f90fa6552
--- /dev/null
+++ b/qadevOOo/runner/util/WaitUnreachable.java
@@ -0,0 +1,119 @@
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed
+ * with this work for additional information regarding copyright
+ * ownership. The ASF licenses this file to you under the Apache
+ * License, Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+package util;
+
+import java.lang.ref.PhantomReference;
+import java.lang.ref.ReferenceQueue;
+
+/**
+ * Wait until an object has become unreachable.
+ *
+ * <p>Instances of this class will typically be used as either:</p>
+ * <pre>
+ * SomeType o = new SomeType(...);
+ * ... // use "o"
+ * WaitUnreachable u = new WaitUnreachable(o);
+ * o = null;
+ * u.waitUnreachable();
+ * </pre>
+ * <p>or:</p>
+ * <pre>
+ * WaitUnreachable u = new WaitUnreachable(new SomeType(...));
+ * ... // use "(SomeType) u.get()"
+ * u.waitUnreachable();
+ * </pre>
+ */
+public final class WaitUnreachable {
+ /**
+ * Creates a new waiter.
+ *
+ * @param obj the object on which to wait
+ */
+ public WaitUnreachable(Object obj) {
+ this.obj = obj;
+ queue = new ReferenceQueue<Object>();
+ ref = new PhantomReference<Object>(obj, queue);
+ }
+
+ /**
+ * Gets the object on which to wait.
+ *
+ * @return the object on which to wait, or <code>null</code> if
+ * <code>waitUnreachable</code> has already been called
+ */
+ public synchronized Object get() {
+ return obj;
+ }
+
+ /**
+ * Starts waiting for the object to become unreachable.
+ *
+ * <p>This blocks the current thread until the object has become
+ * unreachable.</p>
+ *
+ * <p>Actually, this method waits until the JVM has <em>detected</em> that
+ * the object has become unreachable. This is not deterministic, but this
+ * methods makes a best effort to cause the JVM to eventually detect the
+ * situation. With a typical JVM, this should suffice.</p>
+ */
+ public void waitUnreachable() {
+ synchronized (this) {
+ obj = null;
+ }
+ System.out.println("waiting for gc");
+ while (queue.poll() == null) {
+ System.gc();
+ System.runFinalization();
+ }
+ }
+
+ /**
+ * Ensures that an object will be finalized as soon as possible.
+ *
+ * <p>This does not block the current thread. Instead, a new thread is
+ * spawned that busy waits for the given object to become unreachable.</p>
+ *
+ * <p>This method cannot guarantee that the given object is eventually
+ * finalized, but it makes a best effort. With a typical JVM, this should
+ * suffice.</p>
+ *
+ * @param obj the object of which to ensure finalization
+ */
+ public static void ensureFinalization(final Object obj) {
+ final class WaitThread extends Thread {
+ private WaitThread(Object obj) {
+ super("ensureFinalization");
+ unreachable = new WaitUnreachable(obj);
+ }
+
+ @Override
+ public void run() {
+ unreachable.waitUnreachable();
+ }
+
+ private final WaitUnreachable unreachable;
+ }
+ new WaitThread(obj).start();
+ }
+
+ private Object obj;
+ private final ReferenceQueue<Object> queue;
+ @SuppressWarnings("unused")
+ private final PhantomReference<Object> ref;
+}