Java example source code file (OOMEInReferenceHandler.java)

This example Java source code file (OOMEInReferenceHandler.java) is included in the alvinalexander.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" ^TM.

Learn more about this Java project at its project page.

Java - Java tags/keywords

couldn\'t, exception, handler, illegalstateexception, interruptedexception, object, oomeinreferencehandler, outofmemoryerror, reference, referencequeue, threadgroup, weakreference

The OOMEInReferenceHandler.java Java example source code

/*
 * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

/**
 * @test
 * @bug 7038914 8016341
 * @summary Verify that the reference handler does not die after an OOME allocating the InterruptedException object
 * @run main/othervm -Xmx24M -XX:-UseTLAB OOMEInReferenceHandler
 * @author peter.levart@gmail.com
 */

import java.lang.ref.*;

public class OOMEInReferenceHandler {
     static Object[] fillHeap() {
         Object[] first = null, last = null;
         int size = 1 << 20;
         while (size > 0) {
             try {
                 Object[] array = new Object[size];
                 if (first == null) {
                     first = array;
                 } else {
                     last[0] = array;
                 }
                 last = array;
             } catch (OutOfMemoryError oome) {
                 size = size >>> 1;
             }
         }
         return first;
     }

     public static void main(String[] args) throws Exception {
         // preinitialize the InterruptedException class so that the reference handler
         // does not die due to OOME when loading the class if it is the first use
         InterruptedException ie = new InterruptedException("dummy");

         ThreadGroup tg = Thread.currentThread().getThreadGroup();
         for (
             ThreadGroup tgn = tg;
             tgn != null;
             tg = tgn, tgn = tg.getParent()
             )
             ;

         Thread[] threads = new Thread[tg.activeCount()];
         Thread referenceHandlerThread = null;
         int n = tg.enumerate(threads);
         for (int i = 0; i < n; i++) {
             if ("Reference Handler".equals(threads[i].getName())) {
                 referenceHandlerThread = threads[i];
             }
         }

         if (referenceHandlerThread == null) {
             throw new IllegalStateException("Couldn't find Reference Handler thread.");
         }

         ReferenceQueue<Object> refQueue = new ReferenceQueue<>();
         Object referent = new Object();
         WeakReference<Object> weakRef = new WeakReference<>(referent, refQueue);

         Object waste = fillHeap();

         referenceHandlerThread.interrupt();

         // allow referenceHandlerThread some time to throw OOME
         Thread.sleep(500L);

         // release waste & referent
         waste = null;
         referent = null;

         // wait at most 10 seconds for success or failure
         for (int i = 0; i < 20; i++) {
             if (refQueue.poll() != null) {
                 // Reference Handler thread still working -> success
                 return;
             }
             System.gc();
             Thread.sleep(500L); // wait a little to allow GC to do it's work before allocating objects
             if (!referenceHandlerThread.isAlive()) {
                 // Reference Handler thread died -> failure
                 throw new Exception("Reference Handler thread died.");
             }
         }

         // no sure answer after 10 seconds
         throw new IllegalStateException("Reference Handler thread stuck. weakRef.get(): " + weakRef.get());
     }
}