JVM堆模型 - 每天进步一点点！ - ITeye技术网站
博客分类：
JVM堆（Heap）= 新生代（Young） + 旧生代（Tenured）
新生代（Young）= Eden区 + Survivor区
JVM管理的内存叫堆；在32Bit操作系统上有4G的限制，一般来说Windows下为2G，而Linux下为3G；64Bit的就没有这个限 制。
JVM所占用的主要内存都是从堆空间分配的，堆是所有线程共享的，因此在堆上分配内存需要加锁，Sun JDK为提升效率，会为每个新建的线程在Eden上分配一块独立的空间由该线程独享，这块空间称为TLAB（Thread Local Allocation Buffer）。其大小由JVM根据运行情况计算得到，也可通过参数-XX:TLABWasteTargetPercent来设置TLAB可占用的Eden空间的百分比，默认值为1%。在TLAB上分配内存不需要加锁，因此JVM在给线程中的对象分配内存时会尽量在TLAB上分配。如果对象过大或TLAB用完，则仍然在堆上进行分配。
JVM初始分配的内存由-Xms指定，默认是物理内存的1/64但小于1G。
JVM最大分配的内存由-Xmx指定，默认是物理内存的 1/4但小于1G。
默认空余堆内存小于40%时，JVM就会增大堆直到-Xmx的最大限制，可以由-XX:MinHeapFreeRatio=指 定。
默认空余堆内存大于70%时，JVM会减少堆直到-Xms的最小限制，可以由-XX:MaxHeapFreeRatio=指定。
服务器一般设置-Xms、-Xmx相等以避免在每次GC后调整堆的大小，所以上面的两个参数没啥用。
分代/堆模型
分代是Java垃圾收集的一大亮点，根据对象的生命周期长短，把堆分为3个代：Young，Old和Permanent，根据不同代的特点采用不同 的收集算法，可以扬长避短。
分区作用：
新创建的对象通常先将其分配在新生代中，在新生代中经过若干次GC之后仍未释放的对象，再将它移动到旧生代。为了让内存回收更高效（GC会暂停JVM中的应用），Sun JDK在1.2开始对堆采用了分代管理的方式。在分配对象遇到内存不足时，先对新生代进行GC（Young GC）；当新生代GC之后仍无法满足内存空间分配需求时， 才会对整个堆空间以及方法区进行GC （Full GC）
Young(Nursery)：年轻代
研究表明大部分对象都是朝生暮死，随生随灭的。所以对于年轻代在GC时都采取复制收集算法，具体算法参考下面的描述；
Young的默认值为 4M，随堆内存增大，约为1/15，JVM会根据情况动态管理其大小变化。
Young里面又分为3个区域：
一个Eden，所有新建对象都会存在于 该区
两个Survivor区，用来实施复制算法。
Eden区为对象通常最初分配到的地方，Survivor区分为S0和S1两块大小相等的区域。
JVM进行Minor GC时，将Eden中还存活的对象拷贝到Survivor区中，还会将Survivor区中还存活的对象拷贝到Old区中。在这种GC模式下，JVM为了提升GC效率， 将Survivor区分为S0和S1，这样就可以将对象回收和对象晋升分离开来。
-XX:NewRatio= 参数可以设置Young与Old的大小比例，-server时默认为1:2，但实际上young启动时远低于这个比率？如果信不过JVM，也可以用 -Xmn硬性规定其大小，有文档推荐设为Heap总大小的1/4。
-XX:SurvivorRatio= 参数可以设置Eden与Survivor的比例，默认为32。Survivio大了会浪费，小了的话，会使一些年轻对象潜逃到老人区，引起老人区的不安， 但这个参数对性能并不太重要。
Old(Tenured)：年老代
年轻代的对象如果能够挺过数次收集，就会进入老人区。
老人区使用标记整理算法。因为老人区的对象都没那么容易死的，采用复制算法就要反复的复制对 象，很不合算，只好采用标记清理算法，但标记清理算法其实也不轻松，每次都要遍历区域内所有对象，所以还是没有免费的午餐啊。
-XX:MaxTenuringThreshold= 设置熬过年轻代多少次收集后移入老人区，CMS中默认为0，熬过第一次GC就转入，可以用-XX:+PrintTenuringDistribution 查看。
Permanent（Perm）：持久代
装载Class信息等基础数据，默认64M，如果是类很多很多的服务程序，需要加大其设置-XX:MaxPermSize=，否则它满了之后会引起 fullgc()或Out of Memory。 注意Spring，Hibernate这类喜欢AOP动态生成类的框架需要更多的持久代内存。一般情况下，持久代是不会进行GC的，除非通过 -XX:+CMSClassUnloadingEnabled -XX:+CMSPermGenSweepingEnabled进行强制设置。
持久代也被成为方法区，方法区是全局共享的，在一定条件下也会被GC。
持久代存放JVM加载时的类型信息：
类型基本信息
ClassLoader引用
Class类引用
当每个代满了之后都会自动促发collection，各收集器触发的条件不一样，当然也可以通过一些参数进行强制设定。主要分为两种类型：
Minor Collection：GC用较高的频率对young进行扫描和回收，采用复制算法。
Major Collection：同时对Young和Old进行内存收集，也叫Full
GC；因为成本关系对Old的检查回收频率要比Young低很多，采用标记清除/标记整理算法。可以通过调用代码System.gc()引发major collection，使用-XX:+DisableExplicitGC禁止它，或设为CMS并发 -XX:+ExplicitGCInvokesConcurrent。
更为具体的阐述如下：
由于年轻代进进出出的人多而频繁，所以年轻代的GC也就频繁一点，但涉及范围也就年轻代这点弹丸之地内的对象，其特点 就是少量，多次，但快速，称之为Minor Collection。当年轻代的内存使用达到一定的阀值时，Minor Collection就被触发，Eden及某一Survior space（from space）之内存活的的对象被移到另一个空的Survior space（to space）中，然后from space和to space角色对调。当一个对象在两个survivor space之间移动过一定次数（达到预设的阀值）时，它就足够old了，够资格呆在年老代了。当然，如果survivor space比较小不足以容下所有live objects时，部分live objects也会直接晋升到年老代。
Survior spaces可以看作是Eden和年老代之间的缓冲，通过该缓冲可以检验一个对象生命周期是否足够的长，因为某些对象虽然逃过了一次Minor Collection，并不能说明其生命周期足够长，说不定在下一次Minor Collection之前就挂了。这样一定程度上确保了进入年老代的对象是货真价实的，减少了年老代空间使用的增长速度，也就降低年老代GC的频率。
当 年老代或者永久代的内存使用达到一定阀值时，一次基于所有代的GC就触发了，其特定是涉及范围广（量大），耗费的时间相对较长（较慢），但是频率比较低 （次数少），称之为Major Collection(Full Collection)。通常，首先使用针对年轻代的GC算法进行年轻代的GC，然后使用针对年老代的GC算法对年老代和永久代进行GC。
最小收集：
较高频率对年轻代进行扫描、回收
年轻代内存使用达到阀值
---&【触发Min GC】 Eden及from space内的存活对象移入to space
|【不足以容纳所有对象时，部分移入老人代】
---& from/to 角色对调 ---&【一个对象移动到一定次数】
移入老人代
最大收集：
同时对年轻代、年老代、永久代进行内存收集
1、年老代、永久代内存使用达到阀值
2、Yong GC后内存仍然不够分配时
GC收集算法
复制 (copying)：将堆内分成两个相同空间，从根(ThreadLocal的对象，静态对象）开始访问 每一个关联的活跃对象，将空间A的活跃对象全部复制到空间B，然后一次性回收整个空间A。因为只访问活跃对象，将所有活动对象复制走之后就清空整 个空间，不用去访问死对象，所以遍历空间的成本较小，但需要巨大的复制成本和较多的内存。可参考如下的示例图：
标记清除 (mark-sweep)：收集器先从根开始访问所有活跃对象，标记为活跃对象。然后再遍历一次整个 内存区域，把所有没有标记活跃的对象进行回收处理。该算法遍历整个空间的成本较大暂停时间随空间大小线性增大，而且整理后堆里的碎片很多。可参考如下的示 例图：
标记整理 (mark-sweep-compact)：综合了上述两者的做法和优点，先标记活跃对象，然后将其 合并成较大的内存块。可参考如下的示例图：
GC收集算法
1、复制 (copying)
将堆内分成两个相同空间，将空间A的活跃对象全部复制到空间B，然后一次性回收空间A
只访问活跃对象，所以遍历空间成本小，复制成本大
2、标记清除 (mark-sweep)
遍历第一次访问所有活跃对象并标记
遍历第二次回收所有未标记对象
遍历成本大，碎片多
空间越大暂停时间越多
3、标记整理 (mark-sweep-compact)
compact : 压紧、使紧凑
综合了上述两者的做法和优点，标记清理后合并活跃对象成较大的内存块
成本高，但不产生碎片
并行、并发的区别
并行(Parallel)与并发(Concurrent)仅一字之差，但体现的意思却完全不同，这可能也是很多同学非常困惑的地方，要想深刻体会这 其中的差别，可以多揣摩下上面关于GC收集器的示例图；
并行：指多条垃圾收集线程并行，此时用户线程是没有运行的；
并发：指用户线程与垃圾收集线程并发执行，程序在继续运行，而垃圾收集程序运行于另一个个CPU上。
并发收集一开始会很短暂的停止一次所有线程来开始初始标记根对象，然后标记线程与应用线程一起并发运行，最后又很短的暂停一次，多线程并行的重新标 记之前可能因为并发而漏掉的对象，然后就开始与应用程序并发的清除过程。可见，最长的两个遍历过程都是与应用程序并发执行的，比以前的串行算法改进太多太 多了！！！
串行标记清除是等年老代满了再开始收集的，而并发收集因为要与应用程序一起运行，如果满了才收集，应用程序就无内存可用，所以系统默认 68%满的时候就开始收集。内存已设得较大，吃内存又没有这么快的时候，可以用-XX:CMSInitiatingOccupancyFraction= 恰当增大该比率。
年轻代的痛
由于对年轻代的复制收集，依然必须停止所有应用程序线程，原理如此，只能靠多CPU，多收集线程并发来提高收集速度，但除非你的Server独占整 台服务器，否则如果服务器上本身还有很多其他线程时，切换起来速度就..... 所以，搞到最后，暂停时间的瓶颈就落在了年轻代的复制算法上。
因 此Young的大小设置挺重要的 ，大点就不用频繁GC，而且增大GC的间隔后，可以让多点对象自己死掉而不用复制了。 但Young增大时，GC造成的停顿时间攀升得非常恐怖，据某人的测试结果显示：默认8M的Young，只需要几毫秒的时间，64M就升到90毫秒，而升 到256M时，就要到300毫秒了，峰值还会攀到恐怖的800ms。谁叫复制算法，要等Young满了才开始收集，开始收集就要停止所有线程呢。
下载次数: 2
下载次数: 2
下载次数: 4
下载次数: 6
浏览: 1012667 次
来自: 一片神奇的土地
我有个疑问？就是你的text是什么时候有值的，我知道text是 ...
关于el表达式里面fn的用法，下面这个文章讲解的非常全面和详细 ...
java程序语言学习教程 地址http://www.zuida ...
// 密钥是16位长度的byte[]进行Base64转换后得到 ...JVM堆内存设置和测试 - 为程序员服务
JVM堆内存设置和测试
首先Java虚拟机中gc的原理，可以参见
以下是一些个人总结和测试。
1. Java虚拟机内存结构
划分新生代和老年代，这样只在新生代分配内存，从而简化了新对象的分配。另外新生代和老年代使用不同的GC算法，可以更有效的清除不再需要的对象。
从上图可以看出，JVM内存由young+old+permanent组成，JVM又进一步将Young分成了eden，from survivor和to survivor三个区域。新对象会首先分配在 Eden 中(如果新对象过大，会直接分配在老年代中)。在GC中，Eden 中的对象会被移动到survivor中，直至对象熬过一定的GC的次数,会被移动到老年代。老年代一般是一些系统级（线程库，classloader等）的对象，官方推荐新生代占堆大小的3/8，而survivor区各占新生代的1/10。
很多对象的生存时间都很短，而新生对象很少引用生存时间长的对象。所以，GC会频繁访问新生代对象，执行Minor GC。在新生代中，GC可以快速标记回收”死对象”，而不需要扫描整个Heap中的存活一段时间的”老对象”(即执行major/FULL GC)。
新生代的GC使用复制算法。在GC前To survivor区保持清空,对象保存在Eden和From survivor区中，GC运行时,Eden中的幸存对象被复制到 To survivor区。针对 From survivor取中的幸存对象，会考虑对象年龄,如果年龄没达到阀值(tenuring threshold)，对象会被复制到To survivor区。如果达到阀值对象被复制到老年代。复制阶段完成后，Eden 和From survivor区中只保存死对象，可以被视为全部清空。如果在复制过程中To survivor区被填满了，剩余的对象会被复制到老年代中。最后 From和To会对换。
上图演示GC过程，黄色表示死对象，绿色表示剩余空间，红色表示幸存对象
如果新生代过小，会导致新生对象很快就晋升到老年代中，在老年代中对象很难被回收。如果新生代过大，会发生过多的复制过程。所以需要通过不断的测试调优，找到一个合适的JVM参数。
3. JVM内存参数
堆内存大小设置
-Xms :初始堆大小。只要启动，就占用的堆大小
-Xmx :最大堆大小。java.lang.OutOfMemoryError: Java heap这个错误可以通过配置-Xms和-Xmx参数来设置
-Xss：栈大小分配。栈是每个线程私有的区域，通常只有几百K大小，决定了函数调用的深度，而局部变量、参数都分配到栈上。当出现大量局部变量，递归时，会发生栈空间OOM（java.lang.StackOverflowError）之类的错误。
-XX:NewSize=n :设置新生代大小的绝对值
-XX:NewRatio=n: 设置年轻代和年老代的比值。比如设置为3，则新生代：老年代=1：3，新生代占1/4的总heap大小。
-XX:SurvivorRatio=n :年轻代中Eden区与两个Survivor区的比值。注意Survivor区有from和to两个。比如设置为8时，那么eden:from:to=8:1:1
-XX:MaxPermSize=n :设置持久代大小 ；java.lang.OutOfMemoryError: PermGen space这个OOM错误需要合理调大PermSize和MaxPermSize大小。
-XX:HeapDumpOnOutOfMemoryError ：发生OOM时转储堆到文件，这是一个非常好的诊断方法。
-XX:HeapDumpPath ：导出堆的转储文件路径
-XX:OnOutOfMemoryError：OOM时，执行一个脚本，比如发送邮件报警，重启程序。后面跟着一个脚本的路径。
第一次分配5M，没有超过xms。第二次再次分配5M，total mem会增加。第三次再申请40M，超过xmx限制所以报了OOM错误。public class JVMTest {
public static void main(String args[]) {
//=====================Begin=========================
System.out.print("Xmx=");
System.out.println(Runtime.getRuntime().maxMemory() / 1024.0 / 1024 + "M");
System.out.print("free mem=");
System.out.println(Runtime.getRuntime().freeMemory() / 1024.0 / 1024 + "M");
System.out.print("total mem=");
System.out.println(Runtime.getRuntime().totalMemory() / 1024.0 / 1024 + "M");
//=====================First Allocated=========================
System.out.println("5MB array allocated");
byte[] b1 = new byte[5 * 1024 * 1024];
System.out.print("Xmx=");
System.out.println(Runtime.getRuntime().maxMemory() / 1024.0 / 1024 + "M");
System.out.print("free mem=");
System.out.println(Runtime.getRuntime().freeMemory() / 1024.0 / 1024 + "M");
System.out.print("total mem=");
System.out.println(Runtime.getRuntime().totalMemory() / 1024.0 / 1024 + "M");
//=====================Second Allocated=========================
System.out.println("10MB array allocated");
byte[] b2 = new byte[10 * 1024 * 1024];
System.out.print("Xmx=");
System.out.println(Runtime.getRuntime().maxMemory() / 1024.0 / 1024 + "M");
System.out.print("free mem=");
System.out.println(Runtime.getRuntime().freeMemory() / 1024.0 / 1024 + "M");
System.out.print("total mem=");
System.out.println(Runtime.getRuntime().totalMemory() / 1024.0 / 1024 + "M");
//=====================OOM=========================
System.out.println("OOM!!!");
System.gc();
byte[] b3 = new byte[40 * 1024 * 1024];
}以50m XMX和10m XMS的运行测试：D:\&java -Xmx50m -Xms10m JVMTest
free mem=9.438M
total mem=10.5M
MB array allocated
free mem=4.375M
total mem=10.5M
MB array allocated
free mem=5.3125M
total mem=21.0M
Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
at JVMTest.main(JVMTest.java:43)
public class JVMXmn1 {
public static void main(String args[]) {
for(int i=0;i&10;i++)
b=new byte[1*];
下面按1m的新生代设置，这时对象大于新生代大小，会直接创建在老年代。新生代没有使用。没有触发gcD:\&java -Xmx20m -Xms20m -Xmn1m -XX:+PrintGCDetails JVMXmn1
PSYoungGen
total 512K, used 0K [0xfff00, 0x0000)
eden space 0K, -% used [0xfff00000fff00000fff00000)
from space 512K, 0% used [0xfff00000fff0)
space 512K, 0% used [0xfff00000fff00000fff80000)
total 19456K, used 10836K [0xfec000000fff000000fff00000)
object space 19456K, 55% used [0xfec0,0xfff00000)
total 21504K, used 2442K [0xa000000faf000000fec00000)
object space 21504K, 11% used [0xad8,0xfaf00000)
下面按15m的新生代设置，全部分配在eden区，老年代没有使用，没有触发gc。D:\&java -Xmx20m -Xms20m -Xmn15m -XX:+PrintGCDetails JVMXmn1
PSYoungGen
total 13824K, used 11525K [0x0, 0x0000)
eden space 12288K, 93% used [0x00000ffc417c8,0xffd00000)
from space 1536K, 0% used [0xffe00000ffe0)
space 1536K, 0% used [0xffd00000ffd00000ffe80000)
total 5120K, used 0K [0xfea000000fef00)
object space 5120K, 0% used [0xfea00000fea00000fef00000)
total 21504K, used 2442K [0x00000fad000000fea00000)
object space 21504K, 11% used [0xd8,0xfad00000)
下面按8m的新生代设置，触发了一次gc，由于from和to的大小小于1M的对象大小，eden区会直接进入老年代。
D:\&java -Xmx20m -Xms20m -Xmn8m -XX:+PrintGCDetails JVMXmn1
[GC [PSYoungGen: 5954K-&536K(7168K)] 5954K-&K), 0.0021655 secs] [Times: user=0.00 sys=0.00, real=0.00 secs]
PSYoungGen
total 7168K, used 5971K [0x0, 0x0000)
eden space 6144K, 88% used [0x00000ffd4ecb8,0xffe00000)
from space 1024K, 52% used [0xffe00000ffe00000fff00000)
space 1024K, 0% used [0xfff00000fff0)
total 12288K, used 1024K [0xfec00, 0x0000)
object space 12288K, 8% used [0xfec00000fed0)
total 21504K, used 2445K [0xa000000faf000000fec00000)
object space 21504K, 11% used [0xa00,0xfaf00000)
下面按7m的新生代设置，from和to的大小可以为1/xmn,大于触发了3次新生代gc，一共回收了7M左右的空间，最后剩余3M在系统当中，没有使用老年代。
D:\&java -Xmx20m -Xms20m -Xmn7m -XX:SurvivorRatio=2 -XX:+PrintGCDetails JVMXmn1
[GC [PSYoungGen: 3785K-&K)] 3785K-&K), 0.0024118 secs] [Times: user=0.00 sys=0.00, real=0.00 secs]
[GC [PSYoungGen: 4755K-&K)] 4811K-&K), 0.0013799 secs] [Times: user=0.00 sys=0.00, real=0.00 secs]
[GC [PSYoungGen: 4631K-&K)] 4687K-&K), 0.0010990 secs] [Times: user=0.00 sys=0.00, real=0.00 secs]
PSYoungGen
total 5632K, used 2561K [0x0, 0x0000)
eden space 4096K, 26% used [0x00000ffa0a448,0xffd00000)
from space 1536K, 97% used [0xffd00000ffe00000ffe80000)
space 1536K, 0% used [0xffe00000ffe0)
total 13312K, used 56K [0xfec00, 0x0000)
object space 13312K, 0% used [0xfec00000fec0e000,0x0000)
total 21504K, used 2445K [0xa000000faf000000fec00000)
object space 21504K, 11% used [0xa00,0xfaf00000)
新生代占一半大小（10m），幸存区为3：1：1（6m:2m,2m)，触发了1次gc，回收了7m左右空间，没有使用老年代。对于这种临时对象，减少老年代的使用是gc优化的关键。
D:\&java -Xmx20m -Xms20m -XX:NewRatio=1 -XX:SurvivorRatio=3 -XX:+PrintGCDetails JVMXmn1
[GC [PSYoungGen: 5954K-&K)] 5954K-&K), 0.0023152 secs] [Times: user=0.00 sys=0.00, real=0.00 secs]
PSYoungGen
total 8192K, used 7059K [0x0, 0x0000)
eden space 6144K, 88% used [0x00000ffb4ecb8,0xffc00000)
from space 2048K, 79% used [0xffc00000ffd00000ffe00000)
space 2048K, 0% used [0xffe00000ffe0)
total 10240K, used 0K [0xfec00,0x0000)
object space 10240K, 0% used [0xfec00000fec0)
total 21504K, used 2445K [0xa000000faf000000fec00000)
object space 21504K, 11% used [0xa00,0xfaf00000)
原文地址：, 感谢原作者分享。
您可能感兴趣的代码[转]JVM&内存初学&(堆(heap)、栈(stack)和方法区(method)&)
先了解具体的概念：
JAVA的JVM的内存可分为3个区：堆(heap)、栈(stack)和方法区(method)
1.存储的全部是对象，每个对象都包含一个与之对应的class的信息。(class的目的是得到操作指令)
2.jvm只有一个堆区(heap)被所有线程共享，堆中不存放基本类型和对象引用，只存放对象本身栈区:
1.每个线程包含一个栈区，栈中只保存基础数据类型的对象和自定义对象的引用(不是对象)，对象都存放在堆区中
2.每个栈中的数据(原始类型和对象引用)都是私有的，其他栈不能访问。
3.栈分为3个部分：基本类型变量区、执行环境上下文、操作指令区(存放操作指令)。方法区:
1.又叫静态区，跟堆一样，被所有的线程共享。方法区包含所有的class和static变量。
2.方法区中包含的都是在整个程序中永远唯一的元素，如class，static变量。&
为了更清楚地搞明白发生在运行时数据区里的黑幕，我们来准备2个小道具（2个非常简单的小程序）。
AppMain.java
AppMain&&&&&&&&&&&&&&&&//运行时, jvm 把appmain的信息都放入方法区
static&& void&
main(String[] args)& //main
方法本身放入方法区。
Sample test1 = new& Sample(
);&& //test1是引用，所以放到栈区里，
Sample是自定义对象应该放到堆里面
Sample test2 = new& Sample(
测试2 " );
test1.printName();
test2.printName();
Sample.java
Sample&&&&&&&
//运行时, jvm 把appmain的信息都放入方法区
//new Sample实例后，
name 引用放入栈区里，& name
对象放入堆里
public& Sample(String name)
this .name =
printName()&&
//print方法本身放入
方法区里。
System.out.println(name);
OK，让我们开始行动吧，出发指令就是：“java AppMain”，包包里带好我们的行动向导图，Let’s GO！
系统收到了我们发出的指令，启动了一个Java虚拟机进程，这个进程首先从classpath中找到AppMain.class文件，读取这个文件中的二进制数据，然后把Appmain类的类信息存放到运行时数据区的方法区中。这一过程称为AppMain类的加载过程。接着，Java虚拟机定位到方法区中AppMain类的Main()方法的字节码，开始执行它的指令。这个main()方法的第一条语句就是：
Sample test1=new Sample("测试1");语句很简单啦，就是让java虚拟机创建一个Sample实例，并且呢，使引用变量test1引用这个实例。貌似小case一桩哦，就让我们来跟踪一下Java虚拟机，看看它究竟是怎么来执行这个任务的：
Java虚拟机一看，不就是建立一个Sample实例吗，简单，于是就直奔方法区而去，先找到Sample类的类型信息再说。结果呢，嘿嘿，没找到@@，
这会儿的方法区里还没有Sample类呢。可Java虚拟机也不是一根筋的笨蛋，于是，它发扬“自己动手，丰衣足食”的作风，立马加载了Sample类，
把Sample类的类型信息存放在方法区里。
好啦，资料找到了，下面就开始干活啦。Java虚拟机做的第一件事情就是在堆区中为一个新的Sample实例分配内存,
这个Sample实例持有着指向方法区的Sample类的类型信息的引用。这里所说的引用，实际上指的是Sample类的类型信息在方法区中的内存地址，
其实，就是有点类似于C语言里的指针啦~~，而这个地址呢，就存放了在Sample实例的数据区里。
在JAVA虚拟机进程中，每个线程都会拥有一个方法调用栈，用来跟踪线程运行中一系列的方法调用过程，栈中的每一个元素就被称为栈帧，每当线程调用一个方
法的时候就会向方法栈压入一个新帧。这里的帧用来存储方法的参数、局部变量和运算过程中的临时数据。OK，原理讲完了，就让我们来继续我们的跟踪行动！位
于“=”前的Test1是一个在main()方法中定义的变量，可见，它是一个局部变量，因此，它被会添加到了执行main()方法的主线程的JAVA方
法调用栈中。而“=”将把这个test1变量指向堆区中的Sample实例，也就是说，它持有指向Sample实例的引用。
OK，到这里为止呢，JAVA虚拟机就完成了这个简单语句的执行任务。参考我们的行动向导图，我们终于初步摸清了JAVA虚拟机的一点点底细了，COOL！
接下来，JAVA虚拟机将继续执行后续指令，在堆区里继续创建另一个Sample实例，然后依次执行它们的printName()方法。当JAVA虚拟机
执行test1.printName()方法时，JAVA虚拟机根据局部变量test1持有的引用，定位到堆区中的Sample实例，再根据Sample
实例持有的引用，定位到方法去中Sample类的类型信息，从而获得printName()方法的字节码，接着执行printName()方法包含的指
&&/span&三&
在windows中使用taskmanager查看java进程使用的内存时，发现有时候会超过
-Xmx制定的内存大小，
-Xmx指定的是java heap，java还要分配内存做其他的事情，包括为每个线程建立栈。
VM的每个线程都有自己的栈空间，栈空间的大小限制vm的线程数量，太大了，实用的线程数减少，太小容易抛出java.lang.StackOverflowError异常。windows默认为1M，linux必须运行ulimit -s 2048。
在C语言里堆(heap)和栈(stack)里的区别
简单的可以理解为：
heap：是由malloc之类函数分配的空间所在地。地址是由低向高增长的。
stack：是自动分配变量，以及函数调用的时候所使用的一些空间。地址是由高向低减少。
一个由c/C++编译的程序占用的内存分为以下几个部分
1、栈区（stack）—
由编译器自动分配释放
，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈。
2、在Java语言里堆(heap)和栈(stack)里的区别
栈(stack)与堆(heap)都是Java用来在Ram中存放数据的地方。与C++不同，Java自动管理栈和堆，程序员不能直接地设置栈或堆。
栈的优势是，存取速度比堆要快，仅次于直接位于CPU中的寄存器。但缺点是，存在栈中的数据大小与生存期必须是确定的，缺乏灵活性。另外，栈数据可以共享，详见第3点。堆的优势是可以动态地分配内存大小，生存期也不必事先告诉编译器，Java的垃圾收集器会自动收走这些不再使用的数据。但缺点是，由于要在运行时动态分配内存，存取速度较慢。
Java中的数据类型有两种。
　　一种是基本类型(primitive
共有8种，即int, short, long, byte, float, double, boolean,
char(注意，并没有string的基本类型)。这种类型的定义是通过诸如int a = 3; long b = 255L;的形式来定义的，称为自动变量。值得注意的是，自动变量存的是字面值，不是类的实例，即不是类的引用，这里并没有类的存在。如int a = 3;
这里的a是一个指向int类型的引用，指向3这个字面值。这些字面值的数据，由于大小可知，生存期可知(这些字面值固定定义在某个程序块里面，程序块退出后，字段值就消失了)，出于追求速度的原因，就存在于栈中。
　　另外，栈有一个很重要的特殊性，就是存在栈中的数据可以共享。假设我们同时定义
　　int a = 3;
　　int b =
　　编译器先处理int a =
3；首先它会在栈中创建一个变量为a的引用，然后查找有没有字面值为3的地址，没找到，就开辟一个存放3这个字面值的地址，然后将a指向3的地址。接着处理int b = 3；在创建完b的引用变量后，由于在栈中已经有3这个字面值，便将b直接指向3的地址。这样，就出现了a与b同时均指向3的情况。
　　特别注意的是，这种字面值的引用与类对象的引用不同。假定两个类对象的引用同时指向一个对象，如果一个对象引用变量修改了这个对象的内部状态，那么另一个对象引用变量也即刻反映出这个变化。相反，通过字面值的引用来修改其值，不会导致另一个指向此字面值的引用的值也跟着改变的情况。如上例，我们定义完a与
b的值后，再令a=4；那么，b不会等于4，还是等于3。在编译器内部，遇到a=4；时，它就会重新搜索栈中是否有4的字面值，如果没有，重新开辟地址存放4的值；如果已经有了，则直接将a指向这个地址。因此a值的改变不会影响到b的值。
　　另一种是包装类数据，如Integer,
String, Double等将相应的基本数据类型包装起来的类。这些类数据全部存在于堆中，Java用new()语句来显示地告诉编译器，在运行时才根据需要动态创建，因此比较灵活，但缺点是要占用更多的时间。
4.每个JVM的线程都有自己的私有的栈空间，随线程创建而创建，java的stack存放的是frames
，java的stack和c的不同，只是存放本地变量，返回值和调用方法，不允许直接push和pop frames
，因为frames
可能是有heap分配的，所以j为ava的stack分配的内存不需要是连续的。java的heap是所有线程共享的，堆存放所有
runtime data
，里面是所有的对象实例和数组，heap是JVM启动时创建。
String是一个特殊的包装类数据。即可以用String str = new String("abc");的形式来创建，也可以用String str = "abc"；的形式来创建(作为对比，在JDK 5.0之前，你从未见过Integer i = 3;的表达式，因为类与字面值是不能通用的，除了String。而在JDK 5.0中，这种表达式是可以的！因为编译器在后台进行Integer i = new Integer(3)的转换)。前者是规范的类的创建过程，即在Java中，一切都是对象，而对象是类的实例，全部通过new()的形式来创建。Java
中的有些类，如DateFormat类，可以通过该类的getInstance()方法来返回一个新创建的类，似乎违反了此原则。其实不然。该类运用了单例模式来返回类的实例，只不过这个实例是在该类内部通过new()来创建的，而getInstance()向外部隐藏了此细节。那为什么在String str = "abc"；中，并没有通过new()来创建实例，是不是违反了上述原则？其实没有。
关于String str =
"abc"的内部工作。Java内部将此语句转化为以下几个步骤：
　　(1)先定义一个名为str的对String类的对象引用变量：String str；
　　(2)在栈中查找有没有存放值为"abc"的地址，如果没有，则开辟一个存放字面值为"abc"的地址，接着创建一个新的String类的对象o，并将o
的字符串值指向这个地址，而且在栈中这个地址旁边记下这个引用的对象o。如果已经有了值为"abc"的地址，则查找对象o，并返回o的地址。
　　(3)将str指向对象o的地址。
　　值得注意的是，一般String类中字符串值都是直接存值的。但像String str = "abc"；这种场合下，其字符串值却是保存了一个指向存在栈中数据的引用！
为了更好地说明这个问题，我们可以通过以下的几个代码进行验证。
　　String str1 =
　　String str2 =
　　System.out.println(str1==str2); //true
　　注意，我们这里并不用str1.equals(str2)；的方式，因为这将比较两个字符串的值是否相等。==号，根据JDK的说明，只有在两个引用都指向了同一个对象时才返回真值。而我们在这里要看的是，str1与str2是否都指向了同一个对象。
　　结果说明，JVM创建了两个引用str1和str2，但只创建了一个对象，而且两个引用都指向了这个对象。
　　我们再来更进一步，将以上代码改成：
　　String str1 =
　　String str2 =
　　str1 =
　　System.out.println(str1 + "," + str2); //bcd,
　　System.out.println(str1==str2); //false
　　这就是说，赋值的变化导致了类对象引用的变化，str1指向了另外一个新对象！而str2仍旧指向原来的对象。上例中，当我们将str1的值改为"bcd"时，JVM发现在栈中没有存放该值的地址，便开辟了这个地址，并创建了一个新的对象，其字符串的值指向这个地址。
　　事实上，String类被设计成为不可改变(immutable)的类。如果你要改变其值，可以，但JVM在运行时根据新值悄悄创建了一个新对象，然后将这个对象的地址返回给原来类的引用。这个创建过程虽说是完全自动进行的，但它毕竟占用了更多的时间。在对时间要求比较敏感的环境中，会带有一定的不良影响。
　　再修改原来代码：
　　String str1 =
　　String str2 =
　　str1 =
　　String str3 =
　　System.out.println(str3); //bcd
　　String str4 =
　　System.out.println(str1 == str4); //true
这个对象的引用直接指向str1所指向的对象(注意，str3并没有创建新对象)。当str1改完其值后，再创建一个String的引用str4，并指向因str1修改值而创建的新的对象。可以发现，这回str4也没有创建新的对象，从而再次实现栈中数据的共享。
　　我们再接着看以下的代码。
　　String str1 = new
String("abc");
　　String str2 =
　　System.out.println(str1==str2); //false
　　创建了两个引用。创建了两个对象。两个引用分别指向不同的两个对象。
　　String str1 =
　　String str2 = new
String("abc");
　　System.out.println(str1==str2); //false
　　创建了两个引用。创建了两个对象。两个引用分别指向不同的两个对象。
　　以上两段代码说明，只要是用new()来新建对象的，都会在堆中创建，而且其字符串是单独存值的，即使与栈中的数据相同，也不会与栈中的数据共享。
数据类型包装类的值不可修改。不仅仅是String类的值不可修改，所有的数据类型包装类都不能更改其内部的值。
结论与建议：
　　(1)我们在使用诸如String str = "abc"；的格式定义类时，总是想当然地认为，我们创建了String类的对象str。担心陷阱！对象可能并没有被创建！唯一可以肯定的是，指向
String类的引用被创建了。至于这个引用到底是否指向了一个新的对象，必须根据上下文来考虑，除非你通过new()方法来显要地创建一个新的对象。因此，更为准确的说法是，我们创建了一个指向String类的对象的引用变量str，这个对象引用变量指向了某个值为"abc"的String类。清醒地认识到这一点对排除程序中难以发现的bug是很有帮助的。
　　(2)使用String str = "abc"；的方式，可以在一定程度上提高程序的运行速度，因为JVM会自动根据栈中数据的实际情况来决定是否有必要创建新对象。而对于String str = new String("abc")；的代码，则一概在堆中创建新对象，而不管其字符串值是否相等，是否有必要创建新对象，从而加重了程序的负担。这个思想应该是享元模式的思想，但JDK的内部在这里实现是否应用了这个模式，不得而知。
　　(3)当比较包装类里面的数值是否相等时，用equals()方法；当测试两个包装类的引用是否指向同一个对象时，用==。
　　(4)由于String类的immutable性质，当String变量需要经常变换其值时，应该考虑使用StringBuffer类，以提高程序效率。
已投稿到：
以上网友发言只代表其个人观点，不代表新浪网的观点或立场。