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 {
main(String[] args)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 
createBadFinalizer(CountDownLatch finalizerWait)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 
snooze(int ms)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 
BadFinalizer(CountDownLatch finalizerWait)88         public BadFinalizer(CountDownLatch finalizerWait) {
89             this.finalizerWait = finalizerWait;
90         }
91 
finalize()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