blocks|key|1382519|text|它通常是连续的，但这取决于您使用的是哪个JVM。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1382520|Java的一个复杂之处在于，|1382521|对象的内存结构中的运行时不是由虚拟机规范强制执行的，这意味着虚拟机提供者可以随心所欲地实现它们。其结果是，您可以编写一个类，当在另一个VM中运行时，一个VM中该类的实例占用的内存量可能与同一个类的实例占用的内存量不同。|blockquote|1382522|1382523|1382524|至于具体的布局，|1382525|1382526|为了节省一些内存，Sun不会按照声明对象属性的顺序排列这些属性。相反，属性在内存中按以下顺序组织：|1382527|1382528|1382529|1382530|doubles+and+longs|ordered-list-item|1382531|int+and+floats|1382532|shorts+and+floats+and+floats|1382533|1382534|(来自http://www.codeinstructions.com/2008/12/java-objects-memory-structure.html)|offset|length|1382535|他还介绍了如何处理继承的类。|1382536|entityMap|0|LINK|mutability|MUTABLE|url|http://www.codeinstructions.com/2008/12/java-objects-memory-structure.html^0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|3|22|0|0|0^^$0|@$1|2|3|4|5|6|7|1C|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1D|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|1E|8|@]|9|@]|A|$]]|$1|G|3|-4|5|6|7|1F|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|1G|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|1H|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|1I|8|@]|9|@]|A|$]]|$1|L|3|M|5|F|7|1J|8|@]|9|@]|A|$]]|$1|N|3|-4|5|6|7|1K|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|1L|8|@]|9|@]|A|$]]|$1|P|3|-4|5|6|7|1M|8|@]|9|@]|A|$]]|$1|Q|3|R|5|S|7|1N|8|@]|9|@]|A|$]]|$1|T|3|U|5|S|7|1O|8|@]|9|@]|A|$]]|$1|V|3|W|5|S|7|1P|8|@]|9|@]|A|$]]|$1|X|3|-4|5|6|7|1Q|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|6|7|1R|8|@]|9|@$10|1S|11|1T|1|1U]]|A|$]]|$1|12|3|13|5|6|7|1V|8|@]|9|@]|A|$]]|$1|14|3|-4|5|6|7|1W|8|@]|9|@]|A|$]]]|15|$16|$5|17|18|19|A|$1A|1B]]]]

It's generally consecutive but it depends on which JVM you are using.

<blockquote>
 One complication is that runtime in
 memory structure of Java objects is
 not enforced by the virtual machine
 specification, which means that
 virtual machine providers can
 implement them as they please. The
 consequence is that you can write a
 class, and instances of that class in
 one VM can occupy a different amount
 of memory than instances of that same
 class when run in another VM.
</blockquote>

As for the specific layout, 

<blockquote>
 In order to save some memory, the Sun
 VM doesn't lay out object's attributes
 in the same order they are declared.
 Instead, the attributes are organized
 in memory in the following order:
 
 <ol>
 <li>doubles and longs</li>
 <li>ints and floats</li>
 <li>shorts and chars</li>
 <li>booleans and bytes</li>
 <li>references</li>
 </ol>
</blockquote>

(from <a href="http://www.codeinstructions.com/2008/12/java-objects-memory-structure.html" rel="nofollow">http://www.codeinstructions.com/2008/12/java-objects-memory-structure.html</a>) 

He also includes how inherited classes are handled.

blocks|key|3888047|text|首先，在你开始任何工作之前，你已经对你的申请进行了概要分析吗？缓存未命中是否会导致瓶颈？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3888048|您的性能要求是什么？(注意：“越快越好”不是要求*)|3888049|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

Firstly, before you embark on any work, have you profiled your application? Are cache misses causing a bottleneck? 

What are your performance requirements? (Note: 'As fast as possible' isnt a requirement*)

blocks|key|5355969|text|它存储指针。，，dependent.|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5355970|Yes，，，|ordered-list-item|5355971|。这些对象将驻留在其他位置。|5355972|5355973|5355974|entityMap^0|0|1|1|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$]]|$1|E|3|F|5|D|7|M|8|@]|9|@]|A|$]]|$1|G|3|-4|5|6|7|N|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|P|8|@]|9|@]|A|$]]]|J|$]]

<ol>
<li>That would be implementation dependent.</li>
<li>Yes, it stores pointers. The objects will reside elsewhere.</li>
</ol>

blocks|key|5356002|text|JLS并没有严格指定对象的确切大小，因此这在不同的JVM实现中可能会有所不同(尽管您可以推断出一些下限，即一个整数必须至少为32位)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5356003|然而，在Sun的JVM中，整数占用32位，双精度占用64位，对象引用占用32位(除非您在64位JVM上运行，并且禁用了指针压缩)。则对象本身具有2个字的标题，并且总的内存大小对齐为8字节的倍数。|5356004|因此，如果我没有忘记说明某些事情(这是完全可能的)，并且如果您在32位计算机上运行，那么这个对象应该占用8+*+ceil((8+%2B+68+*+4+%2B+22+*+8+%2B+4+*+4)+/+8)+=+10448字节。|offset|length|style|CODE|5356005|但-如上所述，你不应该过于依赖它，因为它没有在任何地方指定，并且的在不同的实现和不同的平台上会有所不同。对于与性能相关的指标，关键是编写干净的代码，测量影响(在这种情况下，使用分析器查看内存使用情况和执行时间)，然后根据需要进行优化。|BOLD|5356006|只有从宏观的角度来看，性能才是真正重要的；在设计对象模型时担心L2缓存未命中确实是错误的做法。|5356007|(而且一个包含94个字段的类几乎肯定不是一个干净的设计，所以您可以考虑重构它……)|5356008|entityMap^0|0|0|1G|17|0|0|1|W|1|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|U|8|@$F|V|G|W|H|I]]|9|@]|A|$]]|$1|J|3|K|5|6|7|X|8|@$F|Y|G|Z|H|L]|$F|10|G|11|H|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|12|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|13|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|14|8|@]|9|@]|A|$]]]|R|$]]

The JLS doesn't strongly specify the exact sizes of objects, so this can vary between JVM implementations (though you can infer some lower bounds, i.e. an integer must be at least 32 bits).

In Sun's JVM however, integers take 32 bits, doubles take 64 bits and object references take 32 bits (unless you're running on a 64-bit JVM and pointer compression is disabled). Then the object itself has a 2 word header, and the overall memory size is aligned to a multiple of 8 bytes.

So overall this object should take <code>8 * ceil((8 + 68 * 4 + 22 * 8 + 4 * 4) / 8)</code> = 10448 bytes, if I haven't forgotten to account for something (which is entirely possible), and if you're running on a 32-bit machine.

But - as stated above, you shouldn't really rely too strongly on this as it's not specified anywhere, and will vary between implementations and on different platforms. As always with performance-related metrics, the key is to write clean code, measure the impact (in this case use a profiler to look at memory usage, and execution time) and then optimise as required.

Performance only really matters from the macro perspective; worrying about L2 cache misses when designing your object model is really the wrong way round to do it.

(And a class with 94 fields is almost certainly not a clean design, so you're right to consider refactoring it...)

blocks|key|1388199|text|一般来说，|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1388200|是这样的。但我认为你不一定想要依赖它。对于低级类型stuff.|ordered-list-item|1388201|Pointers，来说，语言是错误的，但我不确定为什么在性能方面做出重大更改之前会使用这种matters.|1388202|Profile。不过，我认为第二个更干净。难道你不想做一个简单的数组循环来求和吗？|1388203|1388204|或者您可以更改结构以使用较小的类，将在紧密循环中运行的内容放在一起将倾向于提高缓存命中率(假设这是您的性能瓶颈)。|1388205|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|O|8|@]|9|@]|A|$]]|$1|E|3|F|5|D|7|P|8|@]|9|@]|A|$]]|$1|G|3|H|5|D|7|Q|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|R|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|S|8|@]|9|@]|A|$]]|$1|L|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|M|$]]

<ol>
<li>In general, yes. But I don't think you necessarily want to depend on it. Wrong language for that low-level type stuff.</li>
<li>Pointers, but I'm not sure why that matters.</li>
<li>Profile before making significant changes for performance reasons. I think the second is cleaner though. Wouldn't you rather do a simple array loop for your summing?</li>
</ol>

Or you could change the structure to use a smaller class, keeping the stuff that runs in a tight loop together will tend to improve cache hits (iff that is your performance bottleneck).

We have a big class with 68 int, 22 double members, and there are also 4 members as class.
e.g

<pre><code>Class A{

 public int i1

 public int i2

 public int i3

 ....

 public Order order1


 public Order order2

 ...

 public double..

}
</code></pre>

1: Is the memory of i1,i2,i3 is continually physically?

2: For class A, does it store the pointer to order1 &amp; order 2, or it stores the content of order 1 &amp; order 2?

There is another class B which has a member as an array of A, there are 365 A. So the memory for B could be very large. My concern is if the size of B is too huge, we can get lots of cache level 2 missing and degrade the performance. We mainly will sum the value of i1, and sum the value of i2, and sum the value of i3 etc.
e.g if sum i1 for all 365 A, then the i1 for all these 365A will not sit continually in the memory. So we could hit some cache missing and get not good performance. 

I am thinking of using class B but remove the class A, and move all the elements inside A to B, so we can get

<pre><code>Class B {

 public array_of_i1

 public array_of_i2
..

}
</code></pre>

In this way, when I calculate the sum of i1 or i2, then all the i1 or i2 are sitting together, so maybe we could get performance improvement?

As the class is huge, I'd like to look for your opinions before the change.

java: How does the memory of a class member allocate?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我们有一个大的类，有68个int，22个双成员，还有4个成员作为类。e.gClass A{   public int i1   public int i2   public int i3   ....   public Order order1   public Order order2   ...   public ...

问java:类成员的内存是如何分配的？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问java:类成员的内存是如何分配的？EN