1 /* 2 * Copyright (C) 2007 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 import dalvik.system.VMRuntime; 18 import java.util.concurrent.CountDownLatch; 19 import static java.util.concurrent.TimeUnit.MINUTES; 20 21 /** 22 * Test a class with a bad finalizer. 23 * 24 * This test is inherently flaky. It assumes that the system will schedule the finalizer daemon 25 * and finalizer watchdog daemon enough to reach the timeout and throwing the fatal exception. 26 */ 27 public class Main { 28 public static void main(String[] args) throws Exception { 29 CountDownLatch finalizerWait = new CountDownLatch(1); 30 31 // A separate method to ensure no dex register keeps the object alive. 32 createBadFinalizer(finalizerWait); 33 34 // Should have at least two iterations to trigger finalization, but just to make sure run 35 // some more. 36 for (int i = 0; i < 5; i++) { 37 Runtime.getRuntime().gc(); 38 } 39 40 // Now wait for the finalizer to start running. Give it a minute. 41 finalizerWait.await(1, MINUTES); 42 43 // Now fall asleep with a timeout. The timeout is large enough that we expect the 44 // finalizer daemon to have killed the process before the deadline elapses. 45 // The timeout is also large enough to cover the extra 5 seconds we wait 46 // to dump threads, plus potentially substantial gcstress overhead. 47 // Note: the timeout is here (instead of an infinite sleep) to protect the test 48 // environment (e.g., in case this is run without a timeout wrapper). 49 final long timeout = 100 * 1000 + VMRuntime.getRuntime().getFinalizerTimeoutMs(); 50 long remainingWait = timeout; 51 final long waitStart = System.currentTimeMillis(); 52 while (remainingWait > 0) { 53 synchronized (args) { // Just use an already existing object for simplicity... 54 try { 55 args.wait(remainingWait); 56 } catch (Exception e) { 57 } 58 } 59 remainingWait = timeout - (System.currentTimeMillis() - waitStart); 60 } 61 62 // We should not get here. 63 System.out.println("UNREACHABLE"); 64 System.exit(0); 65 } 66 67 private static void createBadFinalizer(CountDownLatch finalizerWait) { 68 BadFinalizer bf = new BadFinalizer(finalizerWait); 69 70 System.out.println("About to null reference."); 71 bf = null; // Not that this would make a difference, could be eliminated earlier. 72 } 73 74 public static void snooze(int ms) { 75 try { 76 Thread.sleep(ms); 77 } catch (InterruptedException ie) { 78 } 79 } 80 81 /** 82 * Class with a bad finalizer. 83 */ 84 public static class BadFinalizer { 85 private CountDownLatch finalizerWait; 86 private volatile int j = 0; // Volatile in an effort to curb loop optimization. 87 88 public BadFinalizer(CountDownLatch finalizerWait) { 89 this.finalizerWait = finalizerWait; 90 } 91 92 protected void finalize() { 93 finalizerWait.countDown(); 94 95 System.out.println("Finalizer started and spinning..."); 96 97 /* spin for a bit */ 98 long start, end; 99 start = System.nanoTime(); 100 snooze(2000); 101 end = System.nanoTime(); 102 System.out.println("Finalizer done spinning."); 103 104 System.out.println("Finalizer sleeping forever now."); 105 while (true) { 106 snooze(10000); 107 } 108 } 109 } 110 } 111
