Runtime.getRuntime().totalMemory()와 freeMemory()는 무엇입니까?

Runtime.getRuntime().totalMemory()와 freeMemory()는 무엇입니까?

Runtime.getRuntime().totalMemory(), Runtime.getRuntime().freeMemory() 및 Runtime.getRuntime()의 정확한 의미는 무엇인지 궁금했습니다.

제가 알기로는Runtime.getRuntime().totalMemory()프로세스에서 사용하고 있는 메모리의 합계가 반환됩니다.그것이 맞습니까?

어때.freeMemory()그리고.maxMemory()?

이름과 값이 헷갈립니다.사용 가능한 메모리의 합계를 찾고 있는 경우는, 스스로 이 값을 계산해 주세요.그것은 당신이 얻을 수 있는 것이 아니다.freeMemory();.

다음의 메뉴얼을 참조해 주세요.

지정된 메모리의 합계.이 값은 구성된 -Xmx 값과 동일합니다.

Runtime.getRuntime().maxMemory();

현재 할당된 사용 가능한 메모리, 새 개체에 사용할 수 있는 현재 할당된 공간입니다.사용 가능한 메모리의 총 용량이 아니라는 점에 주의해 주십시오.

Runtime.getRuntime().freeMemory();

할당된 메모리의 총합은 Java 프로세스에 예약된 총 할당 공간입니다.

Runtime.getRuntime().totalMemory();

사용된 메모리, 계산해야 합니다.

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

총 빈 메모리(계산해야 함):

freeMemory = Runtime.getRuntime().maxMemory() - 사용된 메모리;

그림을 보면 다음 사항을 명확히 알 수 있습니다.

API에 따라

totalMemory()

Java 가상 시스템의 총 메모리 양을 반환합니다.이 메서드에서 반환되는 값은 호스트 환경에 따라 시간에 따라 달라질 수 있습니다.특정 유형의 개체를 유지하는 데 필요한 메모리 양은 구현에 따라 달라질 수 있습니다.

maxMemory()

Java 가상 시스템이 사용하려고 시도할 최대 메모리 양을 반환합니다.고유한 제한이 없는 경우 Long 값이 됩니다.MAX_VALUE가 반환됩니다.

freeMemory()

Java Virtual Machine의 사용 가능한 메모리 양을 반환합니다.gc 메서드를 호출하면 free Memory에서 반환되는 값이 증가할 수 있습니다.

당신의 질문에 대해서,maxMemory()를 반환하다-Xmx가치.

왜 total Memory()와 max Memory()가 있는지 궁금할 수 있습니다.정답은 JVM이 메모리를 느릿느릿 할당하는 것입니다.Java 프로세스를 다음과 같이 시작한다고 가정합니다.

java -Xms64m -Xmx1024m Foo

프로세스는 64 mb의 메모리에서 시작하여 추가 메모리(최대 1024 m)가 필요할 때 메모리를 할당합니다. totalMemory()는 Foo용 JVM에서 현재 사용 가능한 메모리 양에 해당합니다.JVM이 더 많은 메모리를 필요로 하는 경우, JVM은 여유롭게 최대 메모리에 메모리를 할당합니다.를 사용하여 실행한 경우-Xms1024m -Xmx1024m수 있는 " " " 입니다.totalMemory() ★★★★★★★★★★★★★★★★★」maxMemory()게게됩됩됩됩됩

또, 사용된 메모리의 양을 정확하게 계산하려면 , 다음의 계산을 실시합니다.

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

자세한 내용을 확인하려면 다음 프로그램(jdk1.7.x)을 실행합니다.

$ java -Xms1025k -Xmx1025k -XshowSettings:vm  MemoryTest

그러면 jvm 옵션과 jvm에서 사용 가능한 사용된 메모리, 빈 메모리, 총 메모리 및 최대 메모리가 인쇄됩니다.

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");            
        }
}

기타 모든 답변의 성문화 버전(작성 시):

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());
    }
}

Runtime #total Memory - JVM이 지금까지 할당한 메모리.이것은 반드시 사용 중인 것 또는 최대값이 아닙니다.

Runtime #max Memory - JVM이 사용하도록 구성된 최대 메모리 양.프로세스가 이 양에 도달하면 JVM은 더 이상 할당하지 않고 GC의 빈도가 훨씬 높아집니다.

Runtime #free Memory - 이 값이 최대값인지 전체 미사용량인지 알 수 없습니다.미사용분의 측정치라고 생각합니다.

JVM 힙 크기는 가비지 수집 메커니즘을 통해 확장 및 축소할 수 있습니다.그러나 최대 메모리 크기를 초과하여 할당할 수 없습니다.Runtime.max Memory.이것이 최대 메모리의 의미입니다.Total memory는 할당된 힙사이즈를 의미합니다.빈 메모리는 전체 메모리에서 사용 가능한 크기를 의미합니다.

예) java -Xms20M -Xmn10M -Xmx50M ~~~을 참조해 주세요.즉, jvm은 시작 시 힙 20M을 할당해야 합니다.이 경우 총 메모리는 20M이고 빈 메모리는 20M 사용 크기입니다.더 많은 힙이 필요한 경우 JVM은 더 많은 힙을 할당하지만 50M(mx)을 초과할 수 없습니다.최대 메모리는 총 50M, 빈 사이즈는 50M 사용 크기입니다.minumum size(mn)는 히프를 많이 사용하지 않으면 jvm은 히프 사이즈를 10M으로 축소할 수 있습니다.

이 메커니즘은 메모리 효율을 위한 것입니다.작은 Java 프로그램이 거대한 고정 크기 힙 메모리에서 실행된다면 너무 많은 메모리가 낭비될 수 있습니다.

결과는 1024 x 1024로 나누면 1MB에 해당하는 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");  

언급URL : https://stackoverflow.com/questions/3571203/what-are-runtime-getruntime-totalmemory-and-freememory