Return a human readable string representation of the current memory allocation within the Java Virtual Machine. - Java Java Virtual Machine

Java examples for Java Virtual Machine:Memory

Description

Return a human readable string representation of the current memory allocation within the Java Virtual Machine.

Demo Code

/*/*from  w  w  w  .  j a  v  a 2 s.  c o  m*/
 * Copyright (c) 2010-2013, University of Sussex
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 *  * Redistributions of source code must retain the above copyright notice,
 *    this list of conditions and the following disclaimer.
 *
 *  * Redistributions in binary form must reproduce the above copyright notice,
 *    this list of conditions and the following disclaimer in the documentation
 *    and/or other materials provided with the distribution.
 *
 *  * Neither the name of the University of Sussex nor the names of its
 *    contributors may be used to endorse or promote products derived from this
 *    software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */
//package com.java2s;
import javax.annotation.Nonnull;
import java.text.MessageFormat;

public class Main {
    /**
     * SI unit multiples for Byte - increases by a factor of 10^3. Only required
     * up to max long 2^61
     */
    private static final String[] BYTE_UNITS_SUFFIX_SI = { "", "k", "M",
            "G", "T", "P" };
    /**
     * IEC unit multiples for Byte - increases by a factor of 2^10. Only
     * required up to max long 2^61
     */
    private static final String[] BYTE_UNITS_SUFFIX_IEC = { "", "Ki", "Mi",
            "Gi", "Ti", "Pi" };

    /**
     * Return a human readable string representation of the current memory
     * allocation within the Java Virtual Machine.
     * <pre>
     * Memory used=171.7MiB, allocated=444.4MiB, available=1015.7MiB
     * </pre>
     *
     * @return a string containing memory info.
     */
    @Nonnull
    public static String memoryInfoString() {
        return MessageFormat.format(
                "Memory used={0}, allocated={1}, available={2}",
                new Object[] { humanReadableBytes(usedMemory()),
                        humanReadableBytes(allocatedMemory()),
                        humanReadableBytes(maxMemory()) });
    }

    /**
     * Format the provided integer parameter in units of bytes as a
     * human-readable string. For example 2048 produces become "2KiB". Uses
     * non-SI (1024 base) EIC units.
     *
     * @param bytes The number to make a human readable units string newInstance.
     * @return human readable string representation of the number of bytes
     */
    public static String humanReadableBytes(long bytes) {
        return humanReadableBytes(bytes, false, true);
    }

    /**
     * Format the provided integer parameter in units of bytes as a
     * human-readable string. For example 2048 produces become "2KiB". <p> The
     * output can be in either SI base units (multiples of 1000) or the more
     * traditional multiples of 1024 (2<sup>10</sup>). In the case that
     * multiples of 1024 are used, the correct IEC units infix an i character.
     * For example using KiB for kilobyte instead of kB. </p>
     *
     * @param bytes The number to make a human readable units string newInstance.
     * @param si whether to not to use SI (1000) units, use 1024 otherwise
     * @param iec whether or not use IEC units (e.g KiB)
     * @return human readable string representation of the number of bytes
     */
    public static String humanReadableBytes(long bytes, boolean si,
            boolean iec) {

        // Record and strip the sign
        final int signum = Long.signum(bytes);
        final long posBytes = bytes * signum;

        // Calculate the power, for either base 1000 or 1024
        final double byteFrac;
        final String unit;
        long order = 0;
        if (si) {

            long lim = 1000L;
            while (order < BYTE_UNITS_SUFFIX_SI.length && posBytes >= lim) {
                lim *= 1000L;
                order++;
            }
            byteFrac = posBytes / (double) (lim / 1000L);
            unit = BYTE_UNITS_SUFFIX_SI[(int) order];

        } else {

            final String[] units = iec ? BYTE_UNITS_SUFFIX_IEC
                    : BYTE_UNITS_SUFFIX_SI;
            while (order < units.length
                    && posBytes >= 1L << 10L * (order + 1L)) {
                order++;
            }
            byteFrac = posBytes / (double) (1L << (10L * order));
            unit = units[(int) order];
        }

        return String.format(Math.floor(byteFrac) == byteFrac ? "%s%.0f%sB"
                : "%s%.1f%sB", signum == -1 ? "-" : "", byteFrac, unit);
    }

    /**
     * Returns the amount of memory currently used by the Java Virtual Machine.
     * The value returned by this method may vary over time. Calling the
     * {@link Runtime#gc()} method may result in a decreasing the value return
     * by usedMemory.
     *
     * @return an approximation to the amount of memory currently used by
     * allocated objects, measured in bytes.
     */
    public static long usedMemory() {
        return allocatedMemory() - freeAllocatedMemory();
    }

    /**
     * Returns the total amount of memory in the Java virtual machine. The value
     * returned by this method may vary over time, depending on the host
     * environment.
     *
     * @return total amount of memory currently available for current and future
     * objects, measured in bytes.
     */
    public static long allocatedMemory() {
        return Runtime.getRuntime().totalMemory();
    }

    /**
     * Returns the maximum amount of memory that the Java virtual machine will
     * attempt to use. If there is no inherent limit then the value
     * Long.MAX_VALUE will be returned.
     * <p/>
     * Note that this value has no bearing on the actual physical memory
     * availability of the underlying machine, only the upper limit on what the
     * Java Virtual Machine will attempt to allocate.
     *
     * @return the maximum amount of memory that the virtual machine will
     * attempt to use, measured in bytes
     */
    public static long maxMemory() {
        return Runtime.getRuntime().maxMemory();
    }

    /**
     * Returns the amount of free memory in the Java Virtual Machine. Calling
     * the {@link Runtime#gc()} method may result in increasing the value
     * returned by freeMemory.
     *
     * @return an approximation to the total amount of memory currently
     * available for future allocated objects, measured in bytes.
     */
    public static long freeAllocatedMemory() {
        return Runtime.getRuntime().freeMemory();
    }
}

Related Tutorials