java方法区gc_Day7-堆,栈,方法区和GC

Tips

只要类持有对外部实力对象的引用, 垃圾回收机制就不会回收该对象

JVM中

堆和栈对比

存什么

栈内存 存储基本数据类型, 局部变量和方法调用和形参,栈分为java方法栈和native方法栈,

方法栈主要记录的是方法运行时的栈帧, 每执行一个方法就会添加一个栈帧 ,方法返回后, 栈被清空, 堆等待GC回收

为单个函数分配的那部分栈空间叫做栈帧(StackFrame)

正在使用的栈空间叫做调用栈(CallStack)

在内存中，栈是从高地址向低地址延伸的，即栈底对应高地址，栈顶对应低地址。

java线程是不是开两个栈存放不同的栈帧看具体JDK, 比如Oracle JDK和OpenJDK就是一个调用栈存放两种栈帧

堆内存 存储Java中的全部对象,this

int a[] = new int[4];

new int[] 存放在堆, int a[] 存放在栈

Double a[] = new Double[10000000];

Double qq = 3.1d;

for (int i = 0; i < a.length; i++) {

a[i] = qq.doubleValue();

}

a[i] = qq.doubleValue;

a[i] = Double.valueOf(qq);

a[i] = new Double(qq.doubleValue);

所以此double类的值存在堆

独有/共享

栈内存归属于线程, 每个线程都会有一个栈内存, 其存储的变量只能在其所属的线程中可见, 栈内存可以理解成线程的私有内存, 所以叫线程栈

堆内存的对象, 对所有线程可见, 可以被所有线程访问

异常

栈没有空间存储方法调用和局部变量, JVM会抛出Java.lang.StackOverFlowError, 纯java代码无法泄漏栈空间, 它完全被JVM掌控

堆没有空间存储对象, JVM会抛出java.lang.OutOfMemoryError

空间大小

栈内存远小于堆内存, 栈可通过jvm参数 -XSS设置, 默认随着虚拟机和操作系统改变

执行效率

栈是存取效率灵活, 仅次于寄存器, 栈数据可以共享, 但栈中的数据大小和生命周期固定, 缺乏灵活性

堆是自动分配内存大小, 生存期不用告诉编译器, 等gc回收, 但是因为动态分配内存, 存储效率会比较慢

方法区

方法区存类信息, 静态方法, 常量, 即时编译器编译后的代码

GC(Garabage Collection)

指的是堆中数据的回收, 首先堆可以划分为新生代和老年代

新生代继续划分为 Eden 和 Survivor Space(幸存区), Survivor Space 再被划分成 From 和 To

新对象首先被创建在 Eden, (如果对象过大，如数组，则直接放入老年代). 在 GC 中, Eden 会被移入Survivor Space. 直到对象熬过一定的Minor GC的次数, 会被移到老年代, 老年代用Major GC来清理

空间占比:

新生代 : 老年代 = 1:2

Eden : From : To = 8:1:1

分代收集

新生代使用Minor GC, 老年代使用Major GC

Minor GC 和 Major GC 统称为 Full GC

所有的Minor GC 会触发全世界暂停 STW(stop-the-world), 停止应用程序的线程, 当然对于大多数应用，停顿的延迟可以忽略不计, 真相是大部分Eden区中的对象都能被认为是垃圾，所以不会存放到Survivor Space.

现在很多的GC机制都会清理永久代(静态方法区)

JVM并不强制要求GC实现哪种GC算法

纯java代码无法泄漏栈空间, 它完全被JVM掌控, 但如果有其他资源依附在java对象上, 如native memory(DirectByteBuffer), file(fileInputStream), 那么当然自己关闭最合适

虽然有finalizer, PhantomReference之类的让程序员向GC注册, 请求释放资源,但是GC运行时间不确定(因为是一条单独的线程), 还是自己释放的好

可达性检测

引用计数: 一种在jdk1.2之前被使用的垃圾收集算法，我们需要了解其思想。其主要思想就是维护一个counter，当counter为0的时候认为对象没有引用，可以被回收。缺点是无法处理循环引用。目前iOS开发中的一个常见技术ARC(Automatic Reference Counting)也是采用类似的思路。在当前的JVM中应该是没有被使用的。

根搜算法: gc root 根据引用关系来便利整个堆, 并标记, 这称之为Mark, 之后回收掉违背Mark的对象, 解决了「孤岛效应」, 这里的gc root 指的是：

虚拟机栈中引用的对象(栈帧中的本地变量表)

方法区中的类静态属性引用的对象

方法区中的常用变量的对象

本地方法栈中JNI 引用的对象

java减小GC开销 from

不要显示调用System.gc()

此函数只是建议JVM进行GC, 无法保证立马执行

减小临时对象的使用

对象不用时显示置为null

使用StringBuilder拼接字符串

String的扩增是新建对象, 多次 + 会多次创建新对象

能用基本类型就不用对象

少用静态

分散对象创建和删除的时间

整理策略

复制

主要在新生代的回收上, 通过from 和 to 区的来回拷贝.对于新生成的对象, 频繁的复制可以很快找到 那些不用的对象.

标记清除和标记整理

主要在老生代的回收上, 通过根搜的标记清除或者处理掉不用的对象.

整理的过程

清除的过程

清除会产生碎片，对内存的利用不是很好, 但是不代表整理比清除好, 毕竟整理慢, 比如CMSGC就是使用清除而不是整理的

具体的垃圾收集器

新生代收集器：有Serial收集器、ParNew收集器、Parallel Scavenge收集器

老生代收集器：Serial Old收集器、Parallel Old收集器、CMS收集器、G1收集器

思考一下复制和标记清除/整理的区别，为什么新生代要用复制？因为对新生代来讲，一次垃圾收集要回收掉绝大部分对象，我们通过冗余空间的办法来加速整理过程(不冗余空间的整理操作要做swap，而冗余只需要做move)。同时可以记录下每个对象的『年龄』从而优化『晋升』操作使得中年对象不被错误放到老年代。而反过来老年代偏稳定，我们哪怕是用清除，也不会产生太多的碎片，并且整理的代价也并不会太大。

作者：纳达丶无忌

链接：http://www.jianshu.com/p/c9ac99b87d56

來源：简书

著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

寄存器

在计算机领域，寄存器是CPU内部的元件，它是有限存贮容量的高速存贮部件，可用来暂存指令、数据和地址。

寄存器分为通用寄存器和特殊寄存器。通用寄存器有 ax/bx/cx/dx/di/si，在大多数指令中可以任意选用，但也有一些规定某些指令只能用某个特定的「通用」寄存器；特殊寄存器有 bp/sp/ip 等，特殊寄存器均有特定用途。

在 Stack Frame 中，涉及到三种重要的特殊寄存器：

bp ( base pointer ) 寄存器

sp ( stack poinger ) 寄存器

ip ( instruction pointer ) 寄存器

需要注意的是，不同架构的CPU，寄存器名称会添加不同的前缀来表示寄存器的大小。例如对于x86架构，字母「e」用作名称前缀，表示寄存器大小为32位；对于x86_64架构，字母「r」用作名称前缀，表示寄存器大小为64位。

举例

下图是linux 中一个进程的虚拟内存分布：

图中0号地址在最下边，越往上内存地址越大。

以32位地址操作系统为例，一个进程可拥有的虚拟内存地址范围为0-2^32。分为两部分，一部分留给kernel使用(kernel virtual memory)，剩下的是进程本身使用， 即图中的process virtual memory。

普通Java 程序使用的就是process virtual memory.

上图中最顶端的一部分内存叫做user stack. 这就是题目问的 stack. 中间有个 runtime heap。就是题目中的heap. 他们的名字和数据结构里的stack 和 heap 几乎每啥关系。

注意在上图中，stack 是向下生长的; heap是向上生长的。

当程序进行函数调用时，每个函数都在stack上有一个 call frame。

比如对于以下程序，

public void foo(){

//do something...

println("haha"); // <<<=== 在这儿设置breakpoint 1

}

public void bar(){

foo();

}

main(){

bar();

println("hahaha"); // <<<=== 在这儿设置 breakpoint 2

}

当程序运行到breakponit1时，user stack 里会有三个frame

|

| main 函数的 frame－－－－－－－－－－－－－－－－－－－

|

| bar 函数的 frame－－－－－－－－－－－－－－－－－－－<<<=== %ebp

|

| foo 函数的 frame－－－－－－－－－－－－－－－－－－－ <<<===%esp

其中 esp 和 ebp 都是寄存器。 esp 指向stack 的顶(因为stack 向下生长，esp会向下走); ebp 指向当前frame的边界。

当程序继续执行到brekapoing 2的时候stack 大概是这样的:

|

－－－－－－－－－－－－－－－－－－－<<<=== %ebp

|

| main 函数的 frame－－－－－－－－－－－－－－－－－－－ <<<===%esp

也就是说当一个函数执行结束后，它对应的call frame就被销毁了。(其实就是esp 和 ebp分别以东，但是内存地址中的数据只有在下一次写的时候才被覆盖。)

说了这么多，终于该说什么东西放在stack 上什么东西放在heap 上了。

最直白的解释：

public void foo(){

int i = 0; // <= i 的值存在stack上，foo()的call frame 里。

Object obj = new Object(); // object 对象本身存在heap 里， foo()的call frame 里存该对象的地址。

}

数据结构中

栈是先进后出的结构