6ddde10b40
AsynchronousFinalizer was originally added as
870a4401c0 "INTEGRATION: CWS mtg1: #i57753# Avoid
long-running finalize methods" referring to
<https://issues.apache.org/ooo/show_bug.cgi?id=57753> " Fix JNI-UNO bridge so
that the JVM doesn't run out of memory when a destructor locks the SolarMutex."
It is unclear to me how relevant "If JVMs are getting more mature and should no
longer have problems with long-running finalize methods, this class could be
removed again" really is in practice. After all, advice on hotspot-gc-devel is
to avoid finalize() if possible
(<http://mail.openjdk.java.net/pipermail/hotspot-gc-dev/2014-June/010215.html>
"Re: History of finalizer execution and gc progress?"). So stick with this
approach of home-grown draining for now (where a home-grown approach using
PhantomReferencens would need a dedicated draining thread, too, so would not
have much benefit over the existing code in practice).
Timely termination of AsynchronousFinalizer threads is achieved by using a
dedicated thread per bridge and joining it in the remote bridge's dispose()
resp. the JNI environment's new java_env_dispose.
Change-Id: Idcef2dbf361a1de22f60db73828f59e85711aea7
111 lines
4.0 KiB
Java
111 lines
4.0 KiB
Java
/*
|
|
* 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 com.sun.star.lib.util;
|
|
|
|
import java.util.LinkedList;
|
|
|
|
/**
|
|
* Helper class to asynchronously execute finalize methods.
|
|
*
|
|
* <p>Current JVMs seem not to be robust against long-running finalize methods,
|
|
* in that such long-running finalize methods may lead to OutOfMemoryErrors. This
|
|
* class mitigates the problem by asynchronously shifting the bodies of
|
|
* potentially long-running finalize methods into an extra thread. Classes that
|
|
* make use of this in their finalize methods are the proxies used in the
|
|
* intra-process JNI UNO bridge and the inter-process Java URP UNO bridge (where
|
|
* in both cases finalizers lead to synchronous UNO release calls).</p>
|
|
*
|
|
* <p>If JVMs are getting more mature and should no longer have problems with
|
|
* long-running finalize methods, this class could be removed again.</p>
|
|
*/
|
|
public final class AsynchronousFinalizer {
|
|
public AsynchronousFinalizer() {
|
|
thread = new Thread("AsynchronousFinalizer") {
|
|
@Override
|
|
public void run() {
|
|
for (;;) {
|
|
Job j;
|
|
synchronized (queue) {
|
|
for (;;) {
|
|
if (done) {
|
|
return;
|
|
}
|
|
if (!queue.isEmpty()) {
|
|
break;
|
|
}
|
|
try {
|
|
queue.wait();
|
|
} catch (InterruptedException e) {
|
|
return;
|
|
}
|
|
}
|
|
j = queue.remove(0);
|
|
}
|
|
try {
|
|
j.run();
|
|
} catch (Throwable e) {}
|
|
}
|
|
}
|
|
};
|
|
thread.start();
|
|
}
|
|
|
|
/**
|
|
* Add a job to be executed asynchronously.
|
|
*
|
|
* <p>The run method of the given job is called exactly once. If it terminates
|
|
* abnormally by throwing any Throwable, that is ignored.</p>
|
|
*
|
|
* @param job represents the body of some finalize method; must not be null.
|
|
*/
|
|
public void add(Job job) {
|
|
synchronized (queue) {
|
|
boolean first = queue.isEmpty();
|
|
queue.add(job);
|
|
if (first) {
|
|
queue.notify();
|
|
}
|
|
}
|
|
}
|
|
|
|
public void drain() throws InterruptedException {
|
|
synchronized (queue) {
|
|
done = true;
|
|
queue.notify();
|
|
}
|
|
thread.join();
|
|
}
|
|
|
|
/**
|
|
* An interface to represent bodies of finalize methods.
|
|
*
|
|
* Similar to <code>Runnable</code>, except that the run method may throw any
|
|
* <code>Throwable</code> (which is effectively ignored by
|
|
* <code>AsynchronousFinalizer.add</code>, similar to any <code>Throwables</code>
|
|
* raised by finalize being ignored).
|
|
*/
|
|
public interface Job {
|
|
void run() throws Throwable;
|
|
}
|
|
|
|
private final LinkedList<Job> queue = new LinkedList<Job>();
|
|
private final Thread thread;
|
|
private boolean done = false;
|
|
}
|