`
holdbelief
  • 浏览: 707748 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

第一课时提纲:Java 基础(GC)

阅读更多

 一、Java 命名规范

      1、对常量的命名规范:常量名应使用大写字母,单词间用下划线隔开,并且能够见其名知其意。例如:MAX_VALUE 常量用来存储一个最大值。

      2、变量的命名规范:变量名字母要小写,并且要有意义,尽量避免使用单个字符。可以以下划线和字母开头,但不允许以数字开头。

      3、方法名的命名规范:方法是用来被调用一个操作,所以方法名的第一个单词应该是动词,首字母应该小写,其后各个单词的首字母大写。

      4、包的命名规范:报名的命名规范应该全部由小写字母组成。

      5、接口、抽象类、类的命名规范:类名应该使用名词,首字母大写

二、Java 程序的注释

      1、单行注释

       int age = 24; // 定义整型变量用于保存年龄信息

      2、多行注释

      /*

       * 第一行注释

       * 第二行注释

       * ...

       */

      3、文档注释

      /*

       * 第一行注释

       * 第二行注释

       * ...

       */

      文档注释出现在任何声明(例如类的声明、类的成员变量的声明或者类的成员方法的声明)之前时,会被 JavaDoc 文档工具读取作为 JavaDoc 文档内容、文档是对代码结构和功能的描述。

三、常量和变量

      1、常量——final

      2、变量(变量在堆栈中的存储方式,涉及到 1 垃圾回收器,Java对象的生命周期 2 地址引用)

 

 

Java的垃圾回收总结 写道
内存是稀缺的资源,哪怕内存一块钱一条!如果在编程中使用不当,再大的内存也会耗光。

一、认识Java的自动垃圾回收

垃圾回收是Java语言的一大特性,方便了编程,是以消耗性能为代价的。而垃圾在这里只无用的对象。而C++是需要程序员自己写析构函数来释放内存的,麻烦,也有可能忘记而导致内存泄露。

Java语言对内存的分配管理是通过JVM内部机制决定的。程序员可以不关心其处理。

二、垃圾回收的原理和意义

Java虚拟机中有个称之为垃圾回收器的东西,实际上这个东西也许真正不存在,或者是已经集成到JVM中了,但这无关紧要,我们仍然可以称为为垃圾回收器。

垃圾回收器的作用是查找和回收(清理)无用的对象。以便让JVM更有效的使用内存。

垃圾回收器的运行时间是不确定的,由JVM决定,在运行时是间歇执行的。虽然可以通过System.gc()来强制回收垃圾,但是这个命令下达后无法保证JVM会立即响应执行,但经验表明,下达命令后,会在短期内执行你的请求。JVM通常会感到内存紧缺时候去执行垃圾回收操作。

垃圾回收过于频繁会导致性能下降,过于稀疏会导致内存紧缺。这个JVM会将其控制到最好,不用程序员担心。但有些程序在短期会吃掉大量内存,而这些恐怖的对象很快使用结束了,这时候也许有必要强制下达一条垃圾回命令,这是很有必要的,以便有更多可用的物理内存。

从上面了解到,没有用的对象就是垃圾。准确的说,当没有任何线程访问一个对象时,该对象就符合垃圾回收的条件。

对于String,存在一个字符串池,这个不属于本文讨论的范围,字符串池中的垃圾回收,算法和这里所讨论的垃圾回收完全是两码事。但是不得不说的是,字符串的胡乱拼接,往往导致性能急剧下降,尤其是在庞大的循环语句中,拼接字符串就是在让程序慢性自杀。这也是很多Java程序员容易犯的毛病。

字符串既然是池,就是为了缓冲,为了有更高的命中率,因此垃圾回收的频率也许会比JVM对象垃圾回收器要低很多。

垃圾回收器仅仅能做的是尽可能保证可用内存的使用效率,让可用内存得到高效的管理。程序员可以影响垃圾回收的执行,但不能控制。

三、通过编程影响垃圾回收

虽然程序员无法控制JVM的垃圾回收机制。但是可以通过编程的手段来影响,影响的方法是,让对象符合垃圾回收条件。

分别说来有一下几种:

1、将无用对象赋值为null.

2、重新为引用变量赋值。比如:

Person p = new Person("aaa");
p = new Person("bbb");


这样,new Person("aaa")这个对象就是垃圾了——符合垃圾回收条件了。

3、让相互联系的对象称为“岛”对象

Person p1 = new Person("aaa");
Person p2 = new Person("bbb");
Person p3 = new Person("ccc");
p1=p2; p2=p3; p3=p1;
p1=null; p2=null; p3=null;


在没有对p1、p2、p3置null之前,它们之间是一种三角恋关系。分别置null,三角恋关系依然存在,但是三个变量不在使用它们了。三个Person对象就组成了一个孤岛,最后死在堆上——被垃圾回收掉。
我觉得的三角恋关系是错误的, p1=p2; p2=p3; p3=p1; 之后根本没有形成三角恋关系,
因为此时 p1 = p3 = new Person("bbb");
p2 = new Person("ccc");
这里根本没有 new Person("aaa")的事情, 你自己运行一遍这个例子就知道了, 
当p1=p2; p2=p3; p3=p1; 这句代码结束后, new Person("aaa")就已经被GC回收了 —— HoldBelief
2010-03-23 以证实, 三角关系是错误的, 以上红字描述为正确的, 在p1=p2; p2=p3; p3=p1;之后 new Person("aaa"); 就已经符合被回收的条件了, 但是由于GC并不是实时工作, 且必须达到内存的阀值 GC 才工作, 所以 即使new Person("aaa"); 符合回收条件了, 不一定被回收. —— HoldBelief 2010-03-23
4、强制的垃圾回收System.gc()

实际上这里的强制,是程序员的意愿、建议,什么时候执行是JVM的垃圾回收器说了算。

调用垃圾回收也不一定能保证未使用的对象一定能从内存中删除。

唯一能保证的是,当你内存在极少的情况,垃圾回收器在程序抛出OutofMemaryException之前运行一次。
关于: 强制的垃圾回收的易犯错误:
(1)有人认为 即使执行了System.gc() 垃圾回收器也不一定工作, 其理由是 GC 不是实时的. 这种理解是错误的. 让我们看看System.gc()的注释:
/**
     * Runs the garbage collector.
     * Calling this method suggests that the Java virtual machine expend
     * effort toward recycling unused objects in order to make the memory
     * they currently occupy available for quick reuse. When control
     * returns from the method call, the virtual machine has made
     * its best effort to recycle all discarded objects.

     * <p>
     * The name <code>gc</code> stands for "garbage
     * collector". The virtual machine performs this recycling
     * process automatically as needed, in a separate thread, even if the
     * <code>gc</code> method is not invoked explicitly.
     * <p>
     * The method {@link System#gc()} is the conventional and convenient
     * means of invoking this method.
     */
    public native void gc();
注释告诉我们, 当调用 System.gc() 方法后, 垃圾回收器必然工作(不管GC是否实时, 且不管是否达到内存阀值), 但是另一个问题在于, 可能当前线程内没有符合可以被回收的条件的对象, 即使GC 工作了, 也没有什么可以回收的.      —— HoldBelief 2010-03-23
(2)GC与作用域的关系
确切的说GC与作用域没有任何关系。—— java虚拟机中方法调用使用栈结构实现,最后一个被调用的方法特有的相关变量(局部变量、输入输出参数等,值变量或对象变量的“句柄”)保存在栈顶(和我们教科书说的没两样),每一个线程一个栈。 当某个方法执行完毕后,这个方法特有的那些变量就会统统从栈顶中被pop掉, 此时,方法的局部变量全部被pop掉并不代表着方法内部的对象再也没有引用指向它们了,实际上,方法内的对象可能作为输出参数,或者在方法内再启动一个线程,甚至可能在finalize()方法中将对象传递给了别的引用, 造成即使方法结束了, 仍有引用指向在该方法内new 出来的对象, GC 不会回收它们. 由此可见, GC 主要用来控制堆的, 而作用域主要用来控制栈的, 两者没有关系. —— HoldBelief 2010-03-23
四、很神秘的finalize()方法

finalize()方法的确很神秘,是因为你不了解其原理。

原理:1、finalize()方法是Object中的方法。

2、finalize()方法会在对象被垃圾回收之前被垃圾回收器调用一次,这是Java语言的一种机制。

3、finalize()方法在任何对象上最多只会被垃圾回收器调用一次。

陷阱:1、垃圾回收器无法保证垃圾对象能被回收,因此,finalize()方法也无法保证运行。建议不要重写finalize()方法,即使重写,也不要在finalize()方法中写关键的代码。

4、finalize()方法中可以把自己传递个别的对象,这样就不是垃圾了,避免了被回收。但是当下次这个对象又符合垃圾回收的时候,finalize()方法不会被调用第二次了,而是直接被清理掉了。

总结:

理解了垃圾回收的前提是理解Java运行时的内存堆栈模型。

理解Java垃圾回收的目的是为了对Java内存管理有个认识,在编程时更有效的使用内存。

不建议为了垃圾回收,手动编写大量代码,这是很愚蠢的做法。可以通过简单的方式去影响即可。

本文的讨论的垃圾回收排除String对象。String的垃圾回收与String池有很很大关系,目前还没有研究。但是文中已经提及String使用中容易出现的问题。

 

垃圾回收器的使用方法 写道
  看了一些 Thinking in java 这本书后,让我对JAVA的垃圾回收器开始研究起来。 经过摸索,发现java回收器(GC,一下用GC代替回收器)并不是象一般人想像的那样定期的回收垃圾,从而让你完全不用当心内存的问题。事实是,JAVA还是存在内存溢出的时刻,只所以一般的系统和开发人员没有这么认识到,或者没有遇到,只是因为java jvm帮我们默默无闻的做了一些力所能及的处理!!其实,GC的工作原理是非常的复杂,以至于很多人没法说清楚,在这里,我就个人的理解, 总结一下:

1.GC并不是定期来回收你的垃圾内存,即是根据需要来回收。

2.GC的回收是因为:它认为你的系统已经开始内存紧张(这个就是jvm的神奇)

3.即使GC开始准备清理你的垃圾内存,但是如果该内存的引用还存在(不等于null), 这个时候GC仍然无能为力!

看看下面的两个例子就知道了。
例子一:
public class finalizeTest{
public boolean checkout = false.
public void checkIn(){
this.checkout = true.
}
public void finalize(){
if (checkout)
{
System.out.print("the erroe").
}
}
public static void main(String[] args)
{
finalizeTest test = new finalizeTest().
test.checkIn().
System.gc().
System.out.println("Hello World!").
}
}

  本来希望通过System.gc()命令来强制执行finalize()来处理清理事务,但是事与愿违,它没有执行。 只要main方法没执行完,永远都不会被回收。原因很简单,在main方法内 finalizeTest test = new finalizeTest(). 后的“System.gc().”是要求系统去回收垃圾。系统线程此时显然有闲暇时间,经过判断,发现test仍然引用着finalizeTest对象。所以,不会去回收test。

例子二:
public class TestGC{
public void finalize(){
System.out.print("the erroe").
}
public static void main(String[] args)
{
TestGC test = new TestGC().
test = new TestGC().
test = null.
System.gc().
System.out.println("Hello World!").
}
}
  test = null,让test失去了对new TestGC()的引用。new TestGC()对象没有任何人在引用。在你申请GC的时候,就被回收了。因为此时系统只运行你一个线程(还有其他后台辅助的)当然有空闲时间,于是立刻回收了你的。程序输出“the erroeHello World!”。

 

 

Java垃圾回收器工作原理 写道
垃圾回收器是如何工作的?我现在就简单的介绍一下

首先要明确几点:

Java是在堆上为对象分配空间的

垃圾回收器只跟内存有关,什么IO啊,网络连接啊,管它P事

当可用内存数量较低时,Sun版本的垃圾回收器才会被激活

在垃圾回收器回收垃圾之前,我们先来了解一下Java分配对象的方式,Java的堆更像一个传送带,每分配一个新对象,它就往前移动一格。这意味着对象存储空间的分配速度相当快。Java的“堆指针”只是简单地移动到尚未分配的领域。也就是说,分配空间的时候,“堆指针”只管依次往前移动而不管后面的对象是否还要被释放掉。如果可用内存耗尽之前程序就退出就再好不过了,这样的话垃圾回收器压根就不会被激活。

但是由于“堆指针”只管依次往前移动,那么你肯定会想,总有一天内存会被耗尽,垃圾回收器就开始释放内存。这里有人肯定会问:怎么判断某个对象该被回收呢?答案就是当堆栈或静态存储区没有对这个对象的引用时,就表示程序(员)对这个对象没有兴趣了,它就应该被回收了。有两种方法来知道这个对象有没有被引用:第一种是遍历堆上的对象找引用;第二种是遍历堆栈或静态存储区的引用找对象。前者的实现叫做“引用计数法”,意思就是当有引用连接至对象时,引用计数加1,当引用离开作用域或被置为null时,引用计数减1,这种方法有个缺陷,如果对象之间存在循环引用,可能会出现“对象应该被回收,但引用计数却不为零”的情况。

Java采用的是后者,在这种方式下,Java虚拟机采用一种“自适应”的垃圾回收技术,如何处理找到的存活对象(也就是说不是垃圾),Java有两种方式:

一种是“停止-复制”:理论上是先暂停程序的运行(所以它不属于后台回收模式),然后将所有存活的对象从当前堆复制到另一个堆,没有被复制的全是垃圾。当对象被复制到新堆上时,它们是一个挨着一个的,所以新堆保持紧凑排列(这也是为什么分配对象的时候“堆指针”只管依次往前移动)。然后就可以按前述方法简单、直接地分配内存了。这将导致大量内存复制行为,内存分配是以较大的“块”为单位的。有了块之后,垃圾回收器就可以不往堆里拷贝对象了,直接就可以往废弃的块里拷贝对象了。

另一种是“标记-清扫”:它的思路同样是从堆栈和静态存储区出发,遍历所有的引用,进而找出所有存活的对象。每当它找到一个存活对象,就会给对象一个标记。这个过程中不会回收任何对象。只有全部标记完成时,没有标记的对象将被释放,不会发生任何复制工作,所以剩下的堆空间是不连续的,然后垃圾回收器重新整理剩余的对象,使它们是连续排列的。

当垃圾回收器第一次启动时,它执行的是“停止-复制”,因为这个时刻内存有太多的垃圾。然后Java虚拟机会进行监视,如果所有对象都很稳定,垃圾回收器的效率降低的话,就切换到“标记-清扫”方式;同样,Java虚拟机会跟踪“标记-清扫”效果,要是堆空间出现很多碎片,就会切换到“停止-复制”方式。这就是所谓的“自适应”技术。

其实仔细想一下,“停止-复制”和“标记-清扫”无非就是:“在大量的垃圾中找干净的东西和在大量干净的东西里找垃圾”。不同的环境用不同的方式,这样做完全是为了提高效率,要知道,无论哪种方式,Java都会先暂停程序的运行,所以,垃圾回收器的效率其实是很低的。Java用效率换回了C++没有的垃圾回收器和运行时的灵活,我认为这是明智的选择(虽然它只跟内存有关),随着硬件的飞速发展,我相信,开发时间要比运行效率重要得多!

 

分享到:
评论

相关推荐

Global site tag (gtag.js) - Google Analytics