Fatal编程技术网
  • java/
  • Java 我有多少内存'；如果我'；你会运行我的代码吗？

Java 我有多少内存'；如果我'；你会运行我的代码吗？

java jvm

Java 我有多少内存'；如果我'；你会运行我的代码吗？,java,jvm,Java,Jvm,如果我运行此代码，将获得多大的内存 List<Long> list = new LinkedList<>(); for (long i = 0; i < 4_000_000_000L; i++) { list.add(i); } List List=newlinkedlist（）； 对于（长i=0；i

如果我运行此代码，将获得多大的内存

List<Long> list = new LinkedList<>();
for (long i = 0; i < 4_000_000_000L; i++) {
    list.add(i);
}

List List=newlinkedlist（）；
对于（长i=0；i<4\u 000\u 000L；i++）{
列表.添加（i）；
}
8Gb？

可以使用该工具回答此类问题。以下是测试代码：

import org.openjdk.jol.info.GraphLayout;

import org.openjdk.jol.util.VMSupport;
import java.util.*;

public class JOLTest {
    public static void main(String[] args) throws Exception {
        List<Long> list = new LinkedList<>();
        for (long i = 0; i < 4000L; i++) {
            list.add(i);
            if((i+1) % 1000 == 0) {
                System.out.println("i = "+(i+1));
                System.out.println(GraphLayout.parseInstance(list).toFootprint());
            }
        }
    }
}
因此，实际上列表中有
（48*n+32）
字节用于
n
元素，其中
24*n
是
Long
实例，
24*n
是内部
LinkedList$Node
实例，
32
是
LinkedList
本身。因此，您的问题的答案是
192\u 000\u 000\u 032字节
。。。但该测试是针对小型（此类问题可以使用该工具回答。以下是测试代码：

import org.openjdk.jol.info.GraphLayout;

import org.openjdk.jol.util.VMSupport;
import java.util.*;

public class JOLTest {
    public static void main(String[] args) throws Exception {
        List<Long> list = new LinkedList<>();
        for (long i = 0; i < 4000L; i++) {
            list.add(i);
            if((i+1) % 1000 == 0) {
                System.out.println("i = "+(i+1));
                System.out.println(GraphLayout.parseInstance(list).toFootprint());
            }
        }
    }
}
所以你实际上有了
（48*n+32）
为列表中的
n
元素花费的字节，其中
24*n
是
Long
实例，
24*n
是内部
LinkedList$Node
实例，
32
是
LinkedList
本身。因此，您的问题的答案应该是
192*000\u 032字节
…但此测试已执行对于较小的（），可以使用该工具回答此类问题。以下是测试代码：

import org.openjdk.jol.info.GraphLayout;

import org.openjdk.jol.util.VMSupport;
import java.util.*;

public class JOLTest {
    public static void main(String[] args) throws Exception {
        List<Long> list = new LinkedList<>();
        for (long i = 0; i < 4000L; i++) {
            list.add(i);
            if((i+1) % 1000 == 0) {
                System.out.println("i = "+(i+1));
                System.out.println(GraphLayout.parseInstance(list).toFootprint());
            }
        }
    }
}
所以你实际上有了
（48*n+32）
为列表中的
n
元素花费的字节，其中
24*n
是
Long
实例，
24*n
是内部
LinkedList$Node
实例，
32
是
LinkedList
本身。因此，您的问题的答案应该是
192*000\u 032字节
…但此测试已执行对于较小的（），可以使用该工具回答此类问题。以下是测试代码：

import org.openjdk.jol.info.GraphLayout;

import org.openjdk.jol.util.VMSupport;
import java.util.*;

public class JOLTest {
    public static void main(String[] args) throws Exception {
        List<Long> list = new LinkedList<>();
        for (long i = 0; i < 4000L; i++) {
            list.add(i);
            if((i+1) % 1000 == 0) {
                System.out.println("i = "+(i+1));
                System.out.println(GraphLayout.parseInstance(list).toFootprint());
            }
        }
    }
}
所以你实际上有了
（48*n+32）
为列表中的
n
元素花费的字节，其中
24*n
是
Long
实例，
24*n
是内部
LinkedList$Node
实例，
32
是
LinkedList
本身。因此，您的问题的答案应该是
192*000\u 032字节
…但此测试已执行小的（这个问题无法准确回答，其中也有一些错误。1.：8GB=2^33字节，而不是4 bn。2.：an
int
是一个字或4字节长。3.：由于结构的原因，也会有一些开销。4.：虚拟机也会产生一些内存开销。long是64位或8字节，所以8*4000000000字节大致是假设的y、 显然，在我给JVM 12Gb内存（
-Xmx12g
）之前，您将崩溃很久但是，如果它吃32G，那么它无论如何是不够的。这个问题无法准确回答，而且其中也有一些错误。1.：8GB=2^33字节，而不是4 bn。2.：an
int
是一个单词或4字节长。3.：由于结构的原因，也会有一些开销。4.虚拟机也会产生一些内存开销。long是64位或8 b大概是8*4000000000字节。显然，在我给JVM 12Gb内存（
-Xmx12g
）之前，你会崩溃很久但是，如果它吃32G，那么它无论如何是不够的。这个问题无法准确回答，而且其中也有一些错误。1.：8GB=2^33字节，而不是4 bn。2.：an
int
是一个单词或4字节长。3.：由于结构的原因，也会有一些开销。4.虚拟机也会产生一些内存开销。long是64位或8 b大概是8*4000000000字节。显然，在我给JVM 12Gb内存（
-Xmx12g
）之前，你会崩溃很久但是，如果它吃32G，那么它无论如何是不够的。这个问题无法准确回答，而且其中也有一些错误。1.：8GB=2^33字节，而不是4 bn。2.：an
int
是一个单词或4字节长。3.：由于结构的原因，也会有一些开销。4.虚拟机也会产生一些内存开销。long是64位或8 b大概是8*4000000000字节。显然，在我给JVM 12Gb内存（
-Xmx12g
）之前，你会崩溃很久但是，如果它吃32G，那么它无论如何都是不够的。好的。我用一个Long和Byte的列表尝试了它，并在其中放入了2个值。然后在解析这两个列表的实例时，我得到了
java.util。LinkedList@347cdbdfootprint:COUNT AVG SUM DESCRIPTION 2 16 32 java.lang.Long 1 2424 java.util.LinkedList 2 24 48 java.util.LinkedList$Node 5 104（总计）
但我不明白是怎么回事。为什么字节分配的内存也是64字节？@hagrawal，似乎您尝试了32位JVM，对吧？请注意，Long/Byte/etc.是对象，而不是原语，所以您必须为对象标头（其中有指向类的指针，一些位用于支持同步等）花费一些空间。但是，您不必担心字节：只有256个不同的值，它们被缓存（请参见
Byte.valueOf
implementation）。因此，您将不会有超过256个字节的对象（假设您不显式调用
new Byte（）
）很好。我尝试了一个Long和Byte的列表，并在其中放入了2个值。然后在解析这两个列表的实例时，我得到了
java.util。LinkedList@347cdbdfootprint:COUNT AVG SUM DESCRIPTION 2 16 32 java.lang.Long 1 24 java.util.LinkedList 2 2448 java.util.LinkedList$Node 5 104（total）
但我不明白怎么做。为什么字节分配的内存也是64字节？@hagrawal，似乎您在32位JVM上尝试过，对吧？请注意，Long/Byte/等是对象，而不是原语，所以您必须为对象标头花费一些空间（它有指向类的指针、一些支持同步的位等）。不过，您不必担心字节：只有256个不同的值，它们是缓存的（请参阅）