/*
|
* Copyright (C) 2008 The Android Open Source Project
|
*
|
* Licensed 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
|
*
|
* Unless required by applicable law or agreed to in writing, software
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
* See the License for the specific language governing permissions and
|
* limitations under the License.
|
*/
|
|
import java.lang.ref.Reference;
|
import java.lang.ref.WeakReference;
|
import java.util.ArrayList;
|
import java.util.List;
|
|
/**
|
* Some finalizer tests.
|
*
|
* This only works if System.runFinalization() causes finalizers to run
|
* immediately or very soon.
|
*/
|
public class Main {
|
private final static boolean isDalvik = System.getProperty("java.vm.name").equals("Dalvik");
|
|
private static void snooze(int ms) {
|
try {
|
Thread.sleep(ms);
|
} catch (InterruptedException ie) {
|
System.out.println("Snooze: " + ie.getMessage());
|
}
|
}
|
|
public static WeakReference<FinalizerTest> makeRef() {
|
FinalizerTest ft = new FinalizerTest("wahoo");
|
WeakReference<FinalizerTest> ref = new WeakReference<FinalizerTest>(ft);
|
ft = null;
|
return ref;
|
}
|
|
public static String wimpString(final WeakReference<FinalizerTest> wimp) {
|
/*
|
* Do the work in another thread, so there is no danger of a
|
* conservative reference to ft leaking onto the main thread's
|
* stack.
|
*/
|
|
final String[] s = new String[1];
|
Thread t = new Thread() {
|
public void run() {
|
FinalizerTest ref = wimp.get();
|
if (ref != null) {
|
s[0] = ref.toString();
|
}
|
}
|
};
|
|
t.start();
|
|
try {
|
t.join();
|
} catch (InterruptedException ie) {
|
throw new RuntimeException(ie);
|
}
|
|
return s[0];
|
}
|
|
public static void main(String[] args) {
|
WeakReference<FinalizerTest> wimp = makeRef();
|
// Reference ft so we are sure the WeakReference cannot be cleared.
|
// Note: This is very fragile. It was previously in a helper function but that
|
// doesn't work for JIT-on-first-use with --gcstress where the object would be
|
// collected when JIT internally allocates an array. Also adding a scope around
|
// the keepLive lifetime somehow keeps a non-null `keepLive` around and makes
|
// the test fail (even when keeping the `null` assignment). b/76454261
|
FinalizerTest keepLive = wimp.get();
|
System.out.println("wimp: " + wimpString(wimp));
|
Reference.reachabilityFence(keepLive);
|
keepLive = null; // Clear the reference.
|
|
/* this will try to collect and finalize ft */
|
System.out.println("gc");
|
Runtime.getRuntime().gc();
|
|
System.out.println("wimp: " + wimpString(wimp));
|
System.out.println("finalize");
|
System.runFinalization();
|
System.out.println("wimp: " + wimpString(wimp));
|
|
System.out.println("sleep");
|
snooze(1000);
|
|
System.out.println("reborn: " + FinalizerTest.mReborn);
|
System.out.println("wimp: " + wimpString(wimp));
|
System.out.println("reset reborn");
|
Runtime.getRuntime().gc();
|
FinalizerTest.mReborn = FinalizerTest.mNothing;
|
System.out.println("gc + finalize");
|
System.gc();
|
System.runFinalization();
|
|
System.out.println("sleep");
|
snooze(1000);
|
|
System.out.println("reborn: " + FinalizerTest.mReborn);
|
System.out.println("wimp: " + wimpString(wimp));
|
// Test runFinalization with multiple objects.
|
runFinalizationTest();
|
}
|
|
static class FinalizeCounter {
|
public static final int maxCount = 1024;
|
public static boolean finalized[] = new boolean[maxCount];
|
private static Object finalizeLock = new Object();
|
private static volatile int finalizeCount = 0;
|
private int index;
|
static int getCount() {
|
return finalizeCount;
|
}
|
static void printNonFinalized() {
|
for (int i = 0; i < maxCount; ++i) {
|
if (!FinalizeCounter.finalized[i]) {
|
System.out.println("Element " + i + " was not finalized");
|
}
|
}
|
}
|
FinalizeCounter(int index) {
|
this.index = index;
|
}
|
protected void finalize() {
|
synchronized(finalizeLock) {
|
++finalizeCount;
|
finalized[index] = true;
|
}
|
}
|
}
|
|
private static void allocFinalizableObjects(int count) {
|
Object[] objs = new Object[count];
|
for (int i = 0; i < count; ++i) {
|
objs[i] = new FinalizeCounter(i);
|
}
|
}
|
|
private static void runFinalizationTest() {
|
allocFinalizableObjects(FinalizeCounter.maxCount);
|
Runtime.getRuntime().gc();
|
System.runFinalization();
|
if (FinalizeCounter.getCount() != FinalizeCounter.maxCount) {
|
if (isDalvik) {
|
// runFinalization is "expend effort", only ART makes a strong effort all finalizers ran.
|
System.out.println("Finalized " + FinalizeCounter.getCount() + " / " + FinalizeCounter.maxCount);
|
// Print out all the finalized elements.
|
FinalizeCounter.printNonFinalized();
|
}
|
// Try to sleep for a couple seconds to see if the objects became finalized after.
|
try {
|
java.lang.Thread.sleep(2000);
|
} catch (InterruptedException e) {
|
throw new AssertionError(e);
|
}
|
}
|
System.out.println("After sleep finalized " + FinalizeCounter.getCount() + " / " + FinalizeCounter.maxCount);
|
FinalizeCounter.printNonFinalized();
|
}
|
|
public static class FinalizerTest {
|
public static FinalizerTest mNothing = new FinalizerTest("nothing");
|
public static FinalizerTest mReborn = mNothing;
|
|
private final String message;
|
private boolean finalized = false;
|
|
public FinalizerTest(String message) {
|
this.message = message;
|
}
|
|
public String toString() {
|
return "[FinalizerTest message=" + message +
|
", finalized=" + finalized + "]";
|
}
|
|
protected void finalize() {
|
finalized = true;
|
mReborn = this;
|
}
|
}
|
}
|
