Home | History | Annotate | Download | only in src
      1 /*
      2  * Copyright (C) 2008 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 java.lang.ref.WeakReference;
     18 import java.util.ArrayList;
     19 import java.util.List;
     20 
     21 /**
     22  * Some finalizer tests.
     23  *
     24  * This only works if System.runFinalization() causes finalizers to run
     25  * immediately or very soon.
     26  */
     27 public class Main {
     28     private static void snooze(int ms) {
     29         try {
     30             Thread.sleep(ms);
     31         } catch (InterruptedException ie) {
     32             System.out.println("Snooze: " + ie.getMessage());
     33         }
     34     }
     35 
     36     public static WeakReference<FinalizerTest> makeRef() {
     37         /*
     38          * Make ft in another thread, so there is no danger of
     39          * a conservative reference leaking onto the main thread's
     40          * stack.
     41          */
     42 
     43         final List<WeakReference<FinalizerTest>> wimp =
     44                 new ArrayList<WeakReference<FinalizerTest>>();
     45         Thread t = new Thread() {
     46                 public void run() {
     47                     FinalizerTest ft = new FinalizerTest("wahoo");
     48                     wimp.add(new WeakReference<FinalizerTest>(ft));
     49                     ft = null;
     50                 }
     51             };
     52 
     53         t.start();
     54 
     55         try {
     56             t.join();
     57         } catch (InterruptedException ie) {
     58             throw new RuntimeException(ie);
     59         }
     60 
     61         return wimp.get(0);
     62     }
     63 
     64     public static String wimpString(final WeakReference<FinalizerTest> wimp) {
     65         /*
     66          * Do the work in another thread, so there is no danger of a
     67          * conservative reference to ft leaking onto the main thread's
     68          * stack.
     69          */
     70 
     71         final String[] s = new String[1];
     72         Thread t = new Thread() {
     73                 public void run() {
     74                     FinalizerTest ref = wimp.get();
     75                     if (ref != null) {
     76                         s[0] = ref.toString();
     77                     }
     78                 }
     79             };
     80 
     81         t.start();
     82 
     83         try {
     84             t.join();
     85         } catch (InterruptedException ie) {
     86             throw new RuntimeException(ie);
     87         }
     88 
     89         return s[0];
     90     }
     91 
     92     public static void main(String[] args) {
     93         WeakReference<FinalizerTest> wimp = makeRef();
     94 
     95         System.out.println("wimp: " + wimpString(wimp));
     96 
     97         /* this will try to collect and finalize ft */
     98         System.out.println("gc");
     99         Runtime.getRuntime().gc();
    100 
    101         System.out.println("wimp: " + wimpString(wimp));
    102         System.out.println("finalize");
    103         System.runFinalization();
    104         System.out.println("wimp: " + wimpString(wimp));
    105 
    106         System.out.println("sleep");
    107         snooze(1000);
    108 
    109         System.out.println("reborn: " + FinalizerTest.mReborn);
    110         System.out.println("wimp: " + wimpString(wimp));
    111         System.out.println("reset reborn");
    112         Runtime.getRuntime().gc();
    113         FinalizerTest.mReborn = FinalizerTest.mNothing;
    114         System.out.println("gc + finalize");
    115         System.gc();
    116         System.runFinalization();
    117 
    118         System.out.println("sleep");
    119         snooze(1000);
    120 
    121         System.out.println("reborn: " + FinalizerTest.mReborn);
    122         System.out.println("wimp: " + wimpString(wimp));
    123     }
    124 
    125     public static class FinalizerTest {
    126         public static FinalizerTest mNothing = new FinalizerTest("nothing");
    127         public static FinalizerTest mReborn = mNothing;
    128 
    129         private final String message;
    130         private boolean finalized = false;
    131 
    132         public FinalizerTest(String message) {
    133             this.message = message;
    134         }
    135 
    136         public String toString() {
    137             return "[FinalizerTest message=" + message +
    138                     ", finalized=" + finalized + "]";
    139         }
    140 
    141         protected void finalize() {
    142             finalized = true;
    143             mReborn = this;
    144         }
    145     }
    146 }
    147