archive/jdk
1
0
Fork 0
mirror of https://github.com/openjdk/jdk.git synced 2025-08-27 23:04:50 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

8212129: Remove finalize methods from java.util.zip.ZipFIle/Inflator/Deflator

Browse source 
Reviewed-by: rriggs, sherman, alanb, clanger
This commit is contained in:
Lance Andersen 2018-10-26 14:02:31 -04:00
parent 0108d754d7
commit a655e6b52b
5 changed files with 4 additions and 396 deletions
Download patch file Download diff file Expand all files Collapse all files

67
src/java.base/share/classes/java/util/zip/ZipFile.java
View file

@ -56,7 +56,6 @@ import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.IntFunction;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;
import jdk.internal.misc.JavaLangAccess;
@ -85,13 +84,6 @@ import static java.util.zip.ZipUtils.*;
* cleanup mechanisms such as {@link java.lang.ref.Cleaner} and remove the overriding
* {@code finalize} method.
*
* @implSpec
* If this {@code ZipFile} has been subclassed and the {@code close} method has
* been overridden, the {@code close} method will be called by the finalization
* when {@code ZipFile} is unreachable. But the subclasses should not depend on
* this specific implementation; the finalization is not reliable and the
* {@code finalize} method is deprecated to be removed.
*
* @author David Connelly
* @since 1.1
*/
@ -244,7 +236,7 @@ class ZipFile implements ZipConstants, Closeable {
this.name = name;
long t0 = System.nanoTime();
this.res = CleanableResource.get(this, file, mode);
this.res = new CleanableResource(this, file, mode);
PerfCounter.getZipFileOpenTime().addElapsedTimeFrom(t0);
PerfCounter.getZipFileCount().increment();
@ -825,44 +817,6 @@ class ZipFile implements ZipConstants, Closeable {
this.zsrc = Source.get(file, (mode & OPEN_DELETE) != 0);
}
/*
* If {@code ZipFile} has been subclassed and the {@code close} method is
* overridden, uses the {@code finalizer} mechanism for resource cleanup.
* So {@code close} method can be called when the the {@code ZipFile} is
* unreachable. This mechanism will be removed when {@code finalize} method
* is removed from {@code ZipFile}.
*/
static CleanableResource get(ZipFile zf, File file, int mode)
throws IOException {
Class<?> clz = zf.getClass();
while (clz != ZipFile.class && clz != JarFile.class) {
if (JLA.getDeclaredPublicMethods(clz, "close").size() != 0) {
return new FinalizableResource(zf, file, mode);
}
clz = clz.getSuperclass();
}
return new CleanableResource(zf, file, mode);
}
static class FinalizableResource extends CleanableResource {
ZipFile zf;
FinalizableResource(ZipFile zf, File file, int mode)
throws IOException {
super(file, mode);
this.zf = zf;
}
@Override
void clean() {
run();
}
@Override
@SuppressWarnings("deprecation")
protected void finalize() throws IOException {
zf.close();
}
}
}
/**
@ -891,25 +845,6 @@ class ZipFile implements ZipConstants, Closeable {
}
}
/**
* Ensures that the system resources held by this ZipFile object are
* released when there are no more references to it.
*
* @deprecated The {@code finalize} method has been deprecated and will be
* removed. It is implemented as a no-op. Subclasses that override
* {@code finalize} in order to perform cleanup should be modified to
* use alternative cleanup mechanisms and to remove the overriding
* {@code finalize} method. The recommended cleanup for ZipFile object
* is to explicitly invoke {@code close} method when it is no longer in
* use, or use try-with-resources. If the {@code close} is not invoked
* explicitly the resources held by this object will be released when
* the instance becomes unreachable.
*
* @throws IOException if an I/O error has occurred
*/
@Deprecated(since="9", forRemoval=true)
protected void finalize() throws IOException {}
private void ensureOpen() {
if (closeRequested) {
throw new IllegalStateException("zip file closed");