6. 垃圾回收机制

问题一:什么叫垃圾回收机制?
垃圾回收是一种动态存储管理技术,它自动地释放不再被程序引用的对象,按照特定的垃圾收集算法来实现资源自动回收的功能。当一个对象不再被引用的时候,内存回收它占领的空间,以便空间被后来的新对象使用,以免造成内存泄露。

问题二:java的垃圾回收有什么特点?
jAVA语言不允许程序员直接控制内存空间的使用。内存空间的分配和回收都是由JRE负责在后台自动进行的,尤其是无用内存空间的回收操作(garbagecollection,也称垃圾回收),只能由运行环境提供的一个超级线程进行监测和控制。

问题三:垃圾回收器什么时候会运行?
一般是在CPU空闲或空间不足时自动进行垃圾回收,而程序员无法精确控制垃圾回收的时机和顺序等。、

问题四:什么样的对象符合垃圾回收条件?
当没有任何获得线程能访问一个对象时,该对象就符合垃圾回收条件。

问题五:垃圾回收器是怎样工作的?
垃圾回收器如发现一个对象不能被任何活线程访问时,他将认为该对象符合删除条件,就将其加入回收队列,但不是立即销毁对象,何时销毁并释放内存是无法预知的。垃圾回收不能强制执行,然而java提供了一些方法(如:System.gc()方法),允许你请求JVM执行垃圾回收,而不是要求,虚拟机会尽其所能满足请求,但是不能保证JVM从内存中删除所有不用的对象。

问题六:一个java程序能够耗尽内存吗?
可以。垃圾收集系统尝试在对象不被使用时把他们从内存中删除。然而,如果保持太多活的对象,系统则可能会耗尽内存。垃圾回收器不能保证有足够的内存,只能保证可用内存尽可能的得到高效的管理。

问题七:如何显示的使对象符合垃圾回收条件?
(1)空引用:当对象没有对他可到达引用时,他就符合垃圾回收的条件。也就是说如果没有对他的引用,删除对象的引用就可以达到目的,因此我们可以把引用变量设置为null,来符合垃圾回收的条件。

1.StringBuffer sb =newStringBuffer("hello");

2.System.out.println(sb);

3.sb=null;

(2)重新为引用变量赋值:可以通过设置引用变量引用另一个对象来解除该引用变量与一个对象间的引用关系。
StringBuffer sb1 = new StringBuffer(“hello”);
StringBuffer sb2 = new StringBuffer(“goodbye”);
System.out.println(sb1);
sb1=sb2;//此时”hello”符合回收条件
(3)方法内创建的对象:所创建的局部变量仅在该方法的作用期间内存在。一旦该方法返回,在这个方法内创建的对象就符合垃圾收集条件。有一种明显的例外情况,就是方法的返回对象。

1.publicstaticvoid main(String[] args){
2.Date d = getDate();
3.System.out.println("d="+d);
4.}
5.privatestaticDate getDate(){
6.Date d2 =newDate();
7.StringBuffer now =newStringBuffer(d2.toString());
8.System.out.println(now);
9.return d2;
10.}

(4)隔离引用:这种情况中,被回收的对象仍具有引用,这种情况称作隔离岛。若存在这两个实例,他们互相引用,并且这两个对象的所有其他引用都删除,其他任何线程无法访问这两个对象中的任意一个。也可以符合垃圾回收条件。

1.publicclassIsland{
2.Island i;
3.publicstaticvoid main(String[] args){
4.Island i2 =newIsland();
5.Island i3 =newIsland();
6.Island i4 =newIsland();
7.i2. i =i3;
8.i3. i =i4;
9.i4. i =i2;
10.i2=null;
11.i3=null;
12.i4=null;
13.}
14.}

问题八:垃圾收集前进行清理——finalize()方法
java提供了一种机制,使你能够在对象刚要被垃圾回收之前运行一些代码。这段代码位于名为finalize()的方法内,所有类从Object类继承这个方法。由于不能保证垃圾回收器会删除某个对象。因此放在finalize()中的代码无法保证运行。因此建议不要重写finalize();

7.final问题

final使得被修饰的变量”不变”,但是由于对象型变量的本质是”引用”,使得”不变”也有了两种含义:引用本身的不变和引用指向的对象不变。
引用本身的不变:

1.finalStringBuffer a=newStringBuffer("immutable");
2.finalStringBuffer b=newStringBuffer("notimmutable");
3.a=b;//编译期错误
4.finalStringBuffer a=newStringBuffer("immutable");
5.finalStringBuffer b=newStringBuffer("notimmutable");
a=b;//编译期错误
引用指向的对象不变:
1.finalStringBuffer a=newStringBuffer("immutable");
2.a.append("broken!");//编译通过
3.finalStringBuffer a=newStringBuffer("immutable");
4.a.append("broken!");//编译通过

可见,final只对引用的”值”(也即它所指向的那个对象的内存地址)有效,它迫使引用只能指向初始指向的那个对象,改变它的指向会导致编译期错误。至于它所指向的对象的变化,final是不负责的。这很类似==操作符:==操作符只负责引用的”值”相等,至于这个地址所指向的对象内容是否相等,==操作符是不管的。在举一个例子:

1.publicclassName{
2.privateString firstname;
3.privateString lastname;
4.publicString getFirstname(){
5.return firstname;
6.}
7.publicvoid setFirstname(String firstname){
8.this.firstname = firstname;
9.}
10.publicString getLastname(){
11.return lastname;
12.}
13.publicvoid setLastname(String lastname){
14.this.lastname = lastname;
15.}
16.}
17.
18.publicclassName{
19.privateString firstname;
20.privateString lastname;
21.publicString getFirstname(){
22.return firstname;
23.}
24.publicvoid setFirstname(String firstname){
25.this.firstname = firstname;
26.}
27.publicString getLastname(){
28.return lastname;
29.}
30.publicvoid setLastname(String lastname){
31.this.lastname = lastname;
32.}
33.}
编写测试方法:
1.publicstaticvoid main(String[] args){
2.finalName name =newName();
3.name.setFirstname("JIM");
4.name.setLastname("Green");
5.System.out.println(name.getFirstname()+" "+name.getLastname());
6.}
7.publicstaticvoid main(String[] args){
8.finalName name =newName();
9.name.setFirstname("JIM");
10.name.setLastname("Green");
11.System.out.println(name.getFirstname()+" "+name.getLastname());
12.}

理解final问题有很重要的含义。许多程序漏洞都基于此—-final只能保证引用永远指向固定对象,不能保证那个对象的状态不变。在多线程的操作中,一个对象会被多个线程共享或修改,一个线程对对象无意识的修改可能会导致另一个使用此对象的线程崩溃。一个错误的解决方法就是在此对象新建的时候把它声明为final,意图使得它”永远不变”。其实那是徒劳的.final还有一个值得注意的地方,
先看以下示例程序:

1.classSomething{
2.finalint i ;
3.publicvoid doSomething(){
4.System.out.println("i = "+ i );
5.}
6.}
7.classSomething{
8.finalint i;
9.publicvoid doSomething(){
10.System.out.println("i = "+ i);
11.}
12.}

对于类变量,java虚拟机会自动进行初始化。如果给出了初始值,则初始化为该初始值。如果没有给出,则把它初始化为该类型变量的默认初始值。但是对于用final修饰的类变量,虚拟机不会为其赋予初值,必须在constructor(构造器)结束之前被赋予一个明确的值。可以修改为”finalint i = 0;”。

8.如何把程序写得更健壮

(1)尽早释放无用对象的引用。
好的办法是使用临时变量的时候,让引用变量在退出活动域后,自动设置为null,暗示垃圾收集器来收集该对象,防止发生内存泄露。对于仍然有指针指向的实例,jvm就不会回收该资源,因为垃圾回收会将值为null的对象作为垃圾,提高GC回收机制效率;

(2)定义字符串应该尽量使用String str=”hello”;的形式,避免使用String str = new String(“hello”);的形式。因为要使用内容相同的字符串,不必每次都new一个String。例如我们要在构造器中对一个名叫s的String引用变量进行初始化,把它设置为初始值,应当这样做:

1.publicclassDemo{
2.privateString s;
3.publicDemo(){
4.s ="InitialValue";
5.}
6.}
7.
8.publicclassDemo{
9.privateString s;
10....
11.publicDemo{
12.s ="InitialValue";
13.}
14....
15.}
16.而非
17.s =newString("Initial Value");
18.s =newString("InitialValue");

后者每次都会调用构造器,生成新对象,性能低下且内存开销大,并且没有意义,因为String对象不可改变,所以对于内容相同的字符串,只要一个String对象来表示就可以了。也就说,多次调用上面的构造器创建多个对象,他们的String类型属性s都指向同一个对象。

(3)我们的程序里不可避免大量使用字符串处理,避免使用String,应大量使用StringBuffer,因为String被设计成不可变(immutable)类,所以它的所有对象都是不可变对象,请看下列代码;

1.String s ="Hello";
2.s = s +" world!";
3.String s ="Hello";
4.s = s +" world!";

在这段代码中,s原先指向一个String对象,内容是”Hello”,然后我们对s进行了+操作,那么s所指向的那个对象是否发生了改变呢?答案是没有。这时,s不指向原来那个对象了,而指向了另一个String对象,内容为”Hello world!”,原来那个对象还存在于内存之中,只是s这个引用变量不再指向它了。

通过上面的说明,我们很容易导出另一个结论,如果经常对字符串进行各种各样的修改,或者说,不可预见的修改,那么使用String来代表字符串的话会引起很大的内存开销。因为String对象建立之后不能再改变,所以对于每一个不同的字符串,都需要一个String对象来表示。这时,应该考虑使用StringBuffer类,它允许修改,而不是每个不同的字符串都要生成一个新的对象。并且,这两种类的对象转换十分容易。

(4)尽量少用静态变量,因为静态变量是全局的,GC不会回收的;

(5)尽量避免在类的构造函数里创建、初始化大量的对象,防止在调用其自身类的构造器时造成不必要的内存资源浪费,尤其是大对象,JVM会突然需要大量内存,这时必然会触发GC优化系统内存环境;显示的声明数组空间,而且申请数量还极大。
以下是初始化不同类型的对象需要消耗的时间:

运算操作

示例

标准化时间

本地赋值

i = n

1.0

实例赋值

this.i = n

1.2

方法调用

Funct()

5.9

新建对象

New Object()

980

新建数组

New int[10]

3100

从表中可以看出,新建一个对象需要980个单位的时间,是本地赋值时间的980倍,是方法调用时间的166倍,而新建一个数组所花费的时间就更多了。

(6)尽量在合适的场景下使用对象池技术以提高系统性能,缩减缩减开销,但是要注意对象池的尺寸不宜过大,及时清除无效对象释放内存资源,综合考虑应用运行环境的内存资源限制,避免过高估计运行环境所提供内存资源的数量。

(7)大集合对象拥有大数据量的业务对象的时候,可以考虑分块进行处理,然后解决一块释放一块的策略。

(8)不要在经常调用的方法中创建对象,尤其是忌讳在循环中创建对象。可以适当的使用hashtable,vector创建一组对象容器,然后从容器中去取那些对象,而不用每次new之后又丢弃。

(9)一般都是发生在开启大型文件或跟数据库一次拿了太多的数据,造成Out OfMemory Error的状况,这时就大概要计算一下数据量的最大值是多少,并且设定所需最小及最大的内存空间值。

(10)尽量少用finalize函数,因为finalize()会加大GC的工作量,而GC相当于耗费系统的计算能力。

(11)不要过滥使用哈希表,有一定开发经验的开发人员经常会使用hash表(hash表在JDK中的一个实现就是HashMap)来缓存一些数据,从而提高系统的运行速度。比如使用HashMap缓存一些物料信息、人员信息等基础资料,这在提高系统速度的同时也加大了系统的内存占用,特别是当缓存的资料比较多的时候。其实我们可以使用操作系统中的缓存的概念来解决这个问题,也就是给被缓存的分配一个一定大小的缓存容器,按照一定的算法淘汰不需要继续缓存的对象,这样一方面会因为进行了对象缓存而提高了系统的运行效率,同时由于缓存容器不是无限制扩大,从而也减少了系统的内存占用。现在有很多开源的缓存实现项目,比如ehcache、oscache等,这些项目都实现了FIFO 、MRU等常见的缓存算法。



转载于:https://blog.51cto.com/xuchenglang/1323215