Java example source code file (CollectionUsageThreshold.java)

This example Java source code file (CollectionUsageThreshold.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

atomicinteger, brokenbarrierexception, checker, cyclicbarrier, interruptedexception, management, memorynotificationinfo, memorypoolmxbean, notificationemitter, num_gcs, poolrecord, runtimeexception, semaphore, sensorlistener, threading, threads, threshold, util

The CollectionUsageThreshold.java Java example source code

/*
 * Copyright (c) 2003, 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     4959889 6992968
 * @summary Basic unit test of memory management testing:
 *          1) setCollectionUsageThreshold() and getCollectionUsageThreshold()
 *          2) test notification emitted for two different memory pools.
 *
 * @author  Mandy Chung
 *
 * @build CollectionUsageThreshold MemoryUtil
 * @run main/othervm/timeout=300 -XX:+PrintGCDetails -XX:+UseSerialGC CollectionUsageThreshold
 * @run main/othervm/timeout=300 -XX:+PrintGCDetails -XX:+UseParallelGC CollectionUsageThreshold
 * @run main/othervm/timeout=300 -XX:+PrintGCDetails -XX:+UseG1GC CollectionUsageThreshold
 * @run main/othervm/timeout=300 -XX:+PrintGCDetails -XX:+UseConcMarkSweepGC CollectionUsageThreshold
 */

import java.util.*;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
import javax.management.*;
import javax.management.openmbean.CompositeData;
import java.lang.management.*;
import static java.lang.management.MemoryNotificationInfo.*;;
import static java.lang.management.ManagementFactory.*;

public class CollectionUsageThreshold {
    private static final MemoryMXBean mm = getMemoryMXBean();
    private static final Map<String, PoolRecord> result = new HashMap<>();
    private static boolean trace = false;
    private static volatile int numMemoryPools = 1;
    private static final int NUM_GCS = 3;
    private static final int THRESHOLD = 10;
    private static volatile int numGCs = 0;

    // semaphore to signal the arrival of a low memory notification
    private static final Semaphore signals = new Semaphore(0);
    // barrier for the main thread to wait until the checker thread
    // finishes checking the low memory notification result
    private static final CyclicBarrier barrier = new CyclicBarrier(2);

    static class PoolRecord {
        private final MemoryPoolMXBean pool;
        private final AtomicInteger listenerInvoked = new AtomicInteger(0);
        private volatile long notifCount = 0;
        PoolRecord(MemoryPoolMXBean p) {
            this.pool = p;
        }
        int getListenerInvokedCount() {
            return listenerInvoked.get();
        }
        long getNotifCount() {
            return notifCount;
        }
        MemoryPoolMXBean getPool() {
            return pool;
        }
        void addNotification(MemoryNotificationInfo minfo) {
            listenerInvoked.incrementAndGet();
            notifCount = minfo.getCount();
        }
    }

    static class SensorListener implements NotificationListener {
        @Override
        public void handleNotification(Notification notif, Object handback) {
            String type = notif.getType();
            if (MEMORY_THRESHOLD_EXCEEDED.equals(type) ||
                MEMORY_COLLECTION_THRESHOLD_EXCEEDED.equals(type)) {
                MemoryNotificationInfo minfo = MemoryNotificationInfo.
                    from((CompositeData) notif.getUserData());

                MemoryUtil.printMemoryNotificationInfo(minfo, type);
                PoolRecord pr = (PoolRecord) result.get(minfo.getPoolName());
                if (pr == null) {
                    throw new RuntimeException("Pool " + minfo.getPoolName() +
                        " is not selected");
                }
                if (!MEMORY_COLLECTION_THRESHOLD_EXCEEDED.equals(type)) {
                    throw new RuntimeException("Pool " + minfo.getPoolName() +
                        " got unexpected notification type: " +
                        type);
                }
                pr.addNotification(minfo);
                System.out.println("notifying the checker thread to check result");
                signals.release();
            }
        }
    }

    public static void main(String args[]) throws Exception {
        if (args.length > 0 && args[0].equals("trace")) {
            trace = true;
        }

        List<MemoryPoolMXBean> pools = getMemoryPoolMXBeans();
        List<MemoryManagerMXBean> managers = getMemoryManagerMXBeans();

        if (trace) {
            MemoryUtil.printMemoryPools(pools);
            MemoryUtil.printMemoryManagers(managers);
        }

        // Find the Old generation which supports low memory detection
        for (MemoryPoolMXBean p : pools) {
            if (p.isUsageThresholdSupported() && p.isCollectionUsageThresholdSupported()) {
                if (p.getName().toLowerCase().contains("perm")) {
                    // if we have a "perm gen" pool increase the number of expected
                    // memory pools by one.
                    numMemoryPools++;
                }
                PoolRecord pr = new PoolRecord(p);
                result.put(p.getName(), pr);
                if (result.size() == numMemoryPools) {
                    break;
                }
            }
        }
        if (result.size() != numMemoryPools) {
            throw new RuntimeException("Unexpected number of selected pools");
        }

        try {
            // This test creates a checker thread responsible for checking
            // the low memory notifications.  It blocks until a permit
            // from the signals semaphore is available.
            Checker checker = new Checker("Checker thread");
            checker.setDaemon(true);
            checker.start();

            for (PoolRecord pr : result.values()) {
                pr.getPool().setCollectionUsageThreshold(THRESHOLD);
                System.out.println("Collection usage threshold of " +
                    pr.getPool().getName() + " set to " + THRESHOLD);
            }

            SensorListener listener = new SensorListener();
            NotificationEmitter emitter = (NotificationEmitter) mm;
            emitter.addNotificationListener(listener, null, null);

            // The main thread invokes GC to trigger the VM to perform
            // low memory detection and then waits until the checker thread
            // finishes its work to check for a low-memory notification.
            //
            // At GC time, VM will issue low-memory notification and invoke
            // the listener which will release a permit to the signals semaphore.
            // When the checker thread acquires the permit and finishes
            // checking the low-memory notification, it will also call
            // barrier.await() to signal the main thread to resume its work.
            for (int i = 0; i < NUM_GCS; i++) {
                invokeGC();
                barrier.await();
            }
        } finally {
            // restore the default
            for (PoolRecord pr : result.values()) {
                pr.getPool().setCollectionUsageThreshold(0);
            }
        }
        System.out.println("Test passed.");
    }


    private static void invokeGC() {
        System.out.println("Calling System.gc()");
        numGCs++;
        mm.gc();

        if (trace) {
            for (PoolRecord pr : result.values()) {
                System.out.println("Usage after GC for: " + pr.getPool().getName());
                MemoryUtil.printMemoryUsage(pr.getPool().getUsage());
            }
        }
    }

    static class Checker extends Thread {
        Checker(String name) {
            super(name);
        };
        @Override
        public void run() {
            while (true) {
                try {
                    signals.acquire(numMemoryPools);
                    checkResult();
                } catch (InterruptedException | BrokenBarrierException e) {
                    throw new RuntimeException(e);
                }
            }
        }
        private void checkResult() throws InterruptedException, BrokenBarrierException {
            for (PoolRecord pr : result.values()) {
                if (pr.getListenerInvokedCount() != numGCs) {
                    fail("Listeners invoked count = " +
                         pr.getListenerInvokedCount() + " expected to be " +
                         numGCs);
                }
                if (pr.getNotifCount() != numGCs) {
                    fail("Notif Count = " +
                         pr.getNotifCount() + " expected to be " +
                         numGCs);
                }

                long count = pr.getPool().getCollectionUsageThresholdCount();
                if (count != numGCs) {
                    fail("CollectionUsageThresholdCount = " +
                         count + " expected to be " + numGCs);
                }
                if (!pr.getPool().isCollectionUsageThresholdExceeded()) {
                    fail("isCollectionUsageThresholdExceeded" +
                         " expected to be true");
                }
            }
            // wait until the main thread is waiting for notification
            barrier.await();
            System.out.println("notifying main thread to continue - result checking finished");
        }

        private void fail(String msg) {
            // reset the barrier to cause BrokenBarrierException to avoid hanging
            barrier.reset();
            throw new RuntimeException(msg);
        }
    }
}