Java 什么是 Runtime.getRuntime().totalMemory() 和 freeMemory()？

Question

提问by user256239

I've been wondering what the exact meaning of Runtime.getRuntime().totalMemory(), Runtime.getRuntime().freeMemory(), and Runtime.getRuntime().maxMemory()is.

我一直想知道Runtime.getRuntime().totalMemory()、Runtime.getRuntime().freeMemory()和Runtime.getRuntime().maxMemory()的确切含义是什么。

My understanding is, Runtime.getRuntime().totalMemory()returns the total memory my process is using. Is that correct?

我的理解是，Runtime.getRuntime().totalMemory()返回我的进程正在使用的总内存。那是对的吗？

How about freeMemory()and maxMemory()?

freeMemory()和maxMemory()怎么样？

Answer 1

采纳答案by Amir Afghani

According to the API

根据API

totalMemory()

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. Note that the amount of memory required to hold an object of any given type may be implementation-dependent.

返回 Java 虚拟机中的总内存量。此方法返回的值可能会随时间变化，具体取决于主机环境。请注意，保存任何给定类型的对象所需的内存量可能取决于实现。

maxMemory()

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.

返回 Java 虚拟机将尝试使用的最大内存量。如果没有固有限制，则将返回值 Long.MAX_VALUE。

freeMemory()

Returns the amount of free memory in the Java Virtual Machine. Calling the gc method may result in increasing the value returned by freeMemory.

返回 Java 虚拟机中的可用内存量。调用 gc 方法可能会导致 freeMemory 返回的值增加。

In reference to your question, maxMemory()returns the -Xmxvalue.

关于您的问题，maxMemory()返回-Xmx值。

You may be wondering why there is a totalMemory()AND a maxMemory(). The answer is that the JVM allocates memory lazily. Lets say you start your Java process as such:

你可能会奇怪为什么有totalMemory（）和A maxMemory（） 。答案是JVM懒惰地分配内存。假设您这样启动 Java 进程：

java -Xms64m -Xmx1024m Foo

Your process starts with 64mb of memory, and if and when it needs more (up to 1024m), it will allocate memory. totalMemory()corresponds to the amount of memory currentlyavailable to the JVM for Foo. If the JVM needs more memory, it will lazily allocate it upto the maximum memory. If you run with -Xms1024m -Xmx1024m, the value you get from totalMemory()and maxMemory()will be equal.

您的进程以 64mb 内存开始，如果需要更多内存（最多 1024m），它将分配内存。 totalMemory()对应于JVM当前可用于 Foo的内存量。如果JVM需要更多的内存，它会懒洋洋地分配它达到最大内存。如果你运行-Xms1024m -Xmx1024m，你获得的价值totalMemory()和maxMemory()将等于。

Also, if you want to accurately calculate the amount of usedmemory, you do so with the following calculation :

此外，如果您想准确计算已用内存量，请使用以下计算方法：

final long usedMem = totalMemory() - freeMemory();

Answer 2

回答by Tim Bender

Runtime#totalMemory- the memory that the JVM has allocated thus far. This isn't necessarily what is in use or the maximum.

Runtime#totalMemory- JVM 迄今为止分配的内存。这不一定是正在使用的或最大的。

Runtime#maxMemory- the maximum amount of memory that the JVM has been configured to use. Once your process reaches this amount, the JVM will not allocate more and instead GC much more frequently.

Runtime#maxMemory- JVM 已配置为使用的最大内存量。一旦您的进程达到这个数量，JVM 将不会分配更多，而是更频繁地进行 GC。

Runtime#freeMemory- I'm not sure if this is measured from the max or the portion of the total that is unused. I am guessing it is a measurement of the portion of total which is unused.

Runtime#freeMemory- 我不确定这是从最大值还是从未使用的总数部分来衡量的。我猜这是对未使用的总数部分的测量。

Answer 3

回答by ALam-Kim

JVM heap size can be growable and shrinkable by the Garbage-Collection mechanism. But, it can't allocate over maximum memory size: Runtime.maxMemory. This is the meaning of maximum memory. Total memory means the allocated heap size. And free memory means the available size in total memory.

JVM 堆大小可以通过垃圾收集机制进行增长和收缩。但是，它不能分配超过最大内存大小：Runtime.maxMemory。这就是最大内存的含义。总内存是指分配的堆大小。空闲内存意味着总内存中的可用大小。

example) java -Xms20M -Xmn10M -Xmx50M ~~~. This means that jvm should allocate heap 20M on start(ms). In this case, total memory is 20M. free memory is 20M-used size. If more heap is needed, JVM allocate more but can't over 50M(mx). In the case of maximum, total memory is 50M, and free size is 50M-used size. As for minumum size(mn), if heap is not used much, jvm can shrink heap size to 10M.

示例）java -Xms20M -Xmn10M -Xmx50M ~~~。这意味着 jvm 应该在 start(ms) 时分配 20M 堆。在这种情况下，总内存为 20M。空闲内存为 20M 已用大小。如果需要更多堆，JVM 会分配更多但不能超过 50M(mx)。在最大的情况下，总内存为 50M，空闲大小为 50M 已用大小。至于minumum size(mn)，如果heap用的不多，jvm可以把heap size缩小到10M。

This mechanism is for efficiency of memory. If small java program run on huge fixed size heap memory, so much memory may be wasteful.

这种机制是为了提高内存效率。如果小的java程序运行在巨大的固定大小的堆内存上，那么大量的内存可能是浪费的。

Answer 4

回答by Sriram

To understand it better, run this following program (in jdk1.7.x) :

为了更好地理解它，请运行以下程序（在 jdk1.7.x 中）：

$ java -Xms1025k -Xmx1025k -XshowSettings:vm  MemoryTest

$ java -Xms1025k -Xmx1025k -XshowSettings:vm  MemoryTest

This will print jvmoptions and the used, free, totaland maximummemory available in jvm.

这将打印jvm选项以及jvm 中可用的used、free、total和最大内存。

public class MemoryTest {    
    public static void main(String args[]) {
                System.out.println("Used Memory   :  " + (Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory()) + " bytes");
                System.out.println("Free Memory   : " + Runtime.getRuntime().freeMemory() + " bytes");
                System.out.println("Total Memory  : " + Runtime.getRuntime().totalMemory() + " bytes");
                System.out.println("Max Memory    : " + Runtime.getRuntime().maxMemory() + " bytes");            
        }
}

Answer 5

回答by cheneym

The names and values are confusing. If you are looking for the total free memoryyou will have to calculate this value by your self. It is notwhat you get from freeMemory();.

名称和值令人困惑。如果您正在寻找总可用内存，则必须自行计算此值。这不是你从中得到的freeMemory();。

See the following guide:

请参阅以下指南：

Total designated memory, this will equal the configured -Xmxvalue:

总指定内存，这将等于配置的-Xmx值：

Runtime.getRuntime().maxMemory();

Current allocated free memory, is the current allocated space readyfor new objects. Cautionthis is not the total free availablememory:

当前分配的空闲内存，是为新对象准备好的当前分配空间。注意这不是可用的总可用内存：

Runtime.getRuntime().freeMemory();

Total allocated memory, is the total allocated space reservedfor the java process:

总分配内存，是为 java 进程保留的总分配空间：

Runtime.getRuntime().totalMemory();

Used memory, has to be calculated:

使用的内存，必须计算：

usedMemory = Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory();

Total free memory, has to be calculated:

总空闲内存，必须计算：

freeMemory = Runtime.getRuntime().maxMemory() - usedMemory;

A picture may help to clarify:

一张图片可能有助于澄清：

Answer 6

回答by TWiStErRob

Codified version of all other answers (at the time of writing):

所有其他答案的编码版本（在撰写本文时）：

import java.io.*;

/**
 * This class is based on <a href="http://stackoverflow.com/users/2478930/cheneym">cheneym</a>'s
 * <a href="http://stackoverflow.com/a/18375641/253468">awesome interpretation</a>
 * of the Java {@link Runtime}'s memory query methods, which reflects intuitive thinking.
 * Also includes comments and observations from others on the same question, and my own experience.
 * <p>
 * <img src="https://i.stack.imgur.com/GjuwM.png" alt="Runtime's memory interpretation">
 * <p>
 * <b>JVM memory management crash course</b>:
 * Java virtual machine process' heap size is bounded by the maximum memory allowed.
 * The startup and maximum size can be configured by JVM arguments.
 * JVMs don't allocate the maximum memory on startup as the program running may never require that.
 * This is to be a good player and not waste system resources unnecessarily.
 * Instead they allocate some memory and then grow when new allocations require it.
 * The garbage collector will be run at times to clean up unused objects to prevent this growing.
 * Many parameters of this management such as when to grow/shrink or which GC to use
 * can be tuned via advanced configuration parameters on JVM startup.
 *
 * @see <a href="http://stackoverflow.com/a/42567450/253468">
 *     What are Runtime.getRuntime().totalMemory() and freeMemory()?</a>
 * @see <a href="http://www.oracle.com/technetwork/java/javase/memorymanagement-whitepaper-150215.pdf">
 *     Memory Management in the Sun Java HotSpot? Virtual Machine</a>
 * @see <a href="http://docs.oracle.com/javase/8/docs/technotes/tools/windows/java.html">
 *     Full VM options reference for Windows</a>
 * @see <a href="http://docs.oracle.com/javase/8/docs/technotes/tools/unix/java.html">
 *     Full VM options reference for Linux, Mac OS X and Solaris</a>
 * @see <a href="http://www.oracle.com/technetwork/articles/java/vmoptions-jsp-140102.html">
 *     Java HotSpot VM Options quick reference</a>
 */
public class SystemMemory {

    // can be white-box mocked for testing
    private final Runtime runtime = Runtime.getRuntime();

    /**
     * <b>Total allocated memory</b>: space currently reserved for the JVM heap within the process.
     * <p>
     * <i>Caution</i>: this is not the total memory, the JVM may grow the heap for new allocations.
     */
    public long getAllocatedTotal() {
        return runtime.totalMemory();
    }

    /**
     * <b>Current allocated free memory</b>: space immediately ready for new objects.
     * <p>
     * <i>Caution</i>: this is not the total free available memory,
     * the JVM may grow the heap for new allocations.
     */
    public long getAllocatedFree() {
        return runtime.freeMemory();
    }

    /**
     * <b>Used memory</b>:
     * Java heap currently used by instantiated objects. 
     * <p>
     * <i>Caution</i>: May include no longer referenced objects, soft references, etc.
     * that will be swept away by the next garbage collection.
     */
    public long getUsed() {
        return getAllocatedTotal() - getAllocatedFree();
    }

    /**
     * <b>Maximum allocation</b>: the process' allocated memory will not grow any further.
     * <p>
     * <i>Caution</i>: This may change over time, do not cache it!
     * There are some JVMs / garbage collectors that can shrink the allocated process memory.
     * <p>
     * <i>Caution</i>: If this is true, the JVM will likely run GC more often.
     */
    public boolean isAtMaximumAllocation() {
        return getAllocatedTotal() == getTotal();
        // = return getUnallocated() == 0;
    }

    /**
     * <b>Unallocated memory</b>: amount of space the process' heap can grow.
     */
    public long getUnallocated() {
        return getTotal() - getAllocatedTotal();
    }

    /**
     * <b>Total designated memory</b>: this will equal the configured {@code -Xmx} value.
     * <p>
     * <i>Caution</i>: You can never allocate more memory than this, unless you use native code.
     */
    public long getTotal() {
        return runtime.maxMemory();
    }

    /**
     * <b>Total free memory</b>: memory available for new Objects,
     * even at the cost of growing the allocated memory of the process.
     */
    public long getFree() {
        return getTotal() - getUsed();
        // = return getAllocatedFree() + getUnallocated();
    }

    /**
     * <b>Unbounded memory</b>: there is no inherent limit on free memory.
     */
    public boolean isBounded() {
        return getTotal() != Long.MAX_VALUE;
    }

    /**
     * Dump of the current state for debugging or understanding the memory divisions.
     * <p>
     * <i>Caution</i>: Numbers may not match up exactly as state may change during the call.
     */
    public String getCurrentStats() {
        StringWriter backing = new StringWriter();
        PrintWriter out = new PrintWriter(backing, false);
        out.printf("Total: allocated %,d (%.1f%%) out of possible %,d; %s, %s %,d%n",
                getAllocatedTotal(),
                (float)getAllocatedTotal() / (float)getTotal() * 100,
                getTotal(),
                isBounded()? "bounded" : "unbounded",
                isAtMaximumAllocation()? "maxed out" : "can grow",
                getUnallocated()
        );
        out.printf("Used: %,d; %.1f%% of total (%,d); %.1f%% of allocated (%,d)%n",
                getUsed(),
                (float)getUsed() / (float)getTotal() * 100,
                getTotal(),
                (float)getUsed() / (float)getAllocatedTotal() * 100,
                getAllocatedTotal()
        );
        out.printf("Free: %,d (%.1f%%) out of %,d total; %,d (%.1f%%) out of %,d allocated%n",
                getFree(),
                (float)getFree() / (float)getTotal() * 100,
                getTotal(),
                getAllocatedFree(),
                (float)getAllocatedFree() / (float)getAllocatedTotal() * 100,
                getAllocatedTotal()
        );
        out.flush();
        return backing.toString();
    }

    public static void main(String... args) {
        SystemMemory memory = new SystemMemory();
        System.out.println(memory.getCurrentStats());
    }
}

Answer 7

回答by GAbriel lopez

You can see the results in MB format, with the division of 1024 x 1024which is equal to 1 MB.

您可以查看MB 格式的结果，划分为1024 x 1024等于1 MB。

int dataSize = 1024 * 1024;

System.out.println("Used Memory   : " + (Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory())/dataSize + " MB");
System.out.println("Free Memory   : " + Runtime.getRuntime().freeMemory()/dataSize + " MB");
System.out.println("Total Memory  : " + Runtime.getRuntime().totalMemory()/dataSize + " MB");
System.out.println("Max Memory    : " + Runtime.getRuntime().maxMemory()/dataSize + " MB");

Java 什么是 Runtime.getRuntime().totalMemory() 和 freeMemory()？

提问by user256239

采纳答案by Amir Afghani

回答by Tim Bender

回答by ALam-Kim

回答by Sriram

回答by cheneym

回答by TWiStErRob

回答by GAbriel lopez

相关推荐

最近更新

标签

Java 什么是 Runtime.getRuntime().totalMemory() 和 freeMemory()？

提问by user256239

采纳答案by Amir Afghani

回答by Tim Bender

回答by ALam-Kim

回答by Sriram

回答by cheneym

回答by TWiStErRob

回答by GAbriel lopez

相关推荐

如何在java中将时间四舍五入到最近的四分之一小时？

Java 使用 Spring、Play Framework、Struts 构建的网站示例

Java 如何在 FutureTask 中捕获异常

Java 莫基托。验证方法参数

相关推荐

最近更新

标签