可以从不同的的角度去划分垃圾回收算法：
按照基本回收策略分
引用计数（Reference Counting）:
比较古老的回收算法。原理是此对象有一个引用，即增加一个计数，删除一个引用则减少一个计数。垃圾回收时，只用收集计数为0的对象。此算法最致命的是无法处理循环引用的问题。
标记-清除（Mark-Sweep）:
此算法执行分两阶段。第一阶段从引用根节点开始标记所有被引用的对象，第二阶段遍历整个堆，把未标记的对象清除。此算法需要暂停整个应用，同时，会产生内存碎片。
复制（Copying）:
此算法把内存空间划为两个相等的区域，每次只使用其中一个区域。垃圾回收时，遍历当前使用区域，把正在使用中的对象复制到另外一个区域中。次算法每次只处理正在使用中的对象，因此复制成本比较小，同时复制过去以后还能进行相应的内存整理，不会出现“碎片”问题。当然，此算法的缺点也是很明显的，就是需要两倍内存空间。
标记-整理（Mark-Compact）:
此算法结合了“标记-清除”和“复制”两个算法的优点。也是分两阶段，第一阶段从根节点开始标记所有被引用对象，第二阶段遍历整个堆，把清除未标记对象并且把存活对象“压缩”到堆的其中一块，按顺序排放。此算法避免了“标记-清除”的碎片问题，同时也避免了“复制”算法的空间问题。
按分区对待的方式分
增量收集（Incremental Collecting）:实时垃圾回收算法，即：在应用进行的同时进行垃圾回收。不知道什么原因JDK5.0中的收集器没有使用这种算法的。
分代收集（Generational Collecting）:基于对对象生命周期分析后得出的垃圾回收算法。把对象分为年青代、年老代、持久代，对不同生命周期的对象使用不同的算法（上述方式中的一个）进行回收。现在的垃圾回收器（从J2SE1.2开始）都是使用此算法的。
按系统线程分
串行收集:串行收集使用单线程处理所有垃圾回收工作，因为无需多线程交互，实现容易，而且效率比较高。但是，其局限性也比较明显，即无法使用多处理器的优势，所以此收集适合单处理器机器。当然，此收集器也可以用在小数据量（100M左右）情况下的多处理器机器上。
并行收集:并行收集使用多线程处理垃圾回收工作，因而速度快，效率高。而且理论上CPU数目越多，越能体现出并行收集器的优势。
并发收集:相对于串行收集和并行收集而言，前面两个在进行垃圾回收工作时，需要暂停整个运行环境，而只有垃圾回收程序在运行，因此，系统在垃圾回收时会有明显的暂停，而且暂停时间会因为堆越大而越长。
可以从不同的的角度去划分垃圾回收算法： 按照基本回收策略分 引用计数（Reference Counting）: 比较古老的回收算法。原理是此对象有一个引用，即增加一个计数，删除一个引用则减少一个计数。垃圾回收时，只用收集计数为0的对象。此算法最致命的是无法处理循环引用的问题。 标记-清除（Mark-Sweep）: 此算法执行分两阶段。第一阶段从引用根节点开始标记所有被引用的对象，第二阶段遍历整个堆，把未标记的对象清除。此算法需要暂停整个应用，同时，会产生内存碎片。 复制（Copying）:
此算法把内存空间划为两个相等的区域，每次只使用其中一个区域。垃圾回收时，遍历当前使用区域，把正在使用中的对象复制到另外一个区域中。次算法每次只处理正在使用中的对象，因此复制成本比较小，同时复制过去以后还能进行相应的内存整理，不会出现“碎片”问题。当然，此算法的缺点也是很明显的，就是需要两倍内存空间。 标记-整理（Mark-Compact）:
此算法结合了“标记-清除”和“复制”两个算法的优点。也是分两阶段，第一阶段从根节点开始标记所有被引用对象，第二阶段遍历整个堆，把清除未标记对象并且把存活对象“压缩”到堆的其中一块，按顺序排放。此算法避免了“标记-清除”的碎片问题，同时也避免了“复制”算法的空间问题。 按分区对待的方式分 增量收集（Incremental Collecting）:实时垃圾回收算法，即：在应用进行的同时进行垃圾回收。不知道什么原因JDK5.0中的收集器没有使用这种算法的。 分代收集（Generational Collecting）:基于对对象生命周期分析后得出的垃圾回收算法。把对象分为年青代、年老代、持久代，对不同生命周期的对象使用不同的算法（上述方式中的一个）进行回收。现在的垃圾回收器（从J2SE1.2开始）都是使用此算法的。 按系统线程分 串行收集:串行收集使用单线程处理所有垃圾回收工作，因为无需多线程交互，实现容易，而且效率比较高。但是，其局限性也比较明显，即无法使用多处理器的优势，所以此收集适合单处理器机器。当然，此收集器也可以用在小数据量（100M左右）情况下的多处理器机器上。 并行收集:并行收集使用多线程处理垃圾回收工作，因而速度快，效率高。而且理论上CPU数目越多，越能体现出并行收集器的优势。 并发收集:相对于串行收集和并行收集而言，前面两个在进行垃圾回收工作时，需要暂停整个运行环境，而只有垃圾回收程序在运行，因此，系统在垃圾回收时会有明显的暂停，而且暂停时间会因为堆越大而越长。
JVM的垃圾回收机制小读 技术2010-05-09 19:41:04 阅读20 评论2 字号：大中小订阅 今天下午突然遇到了一个内存漏洞的问题，所以上网查了查，结果看到了一篇文章，说的是jvm的垃圾回收机制，下面粘过来，看了好久才看完的，说的思路有点含糊，还给带了点代码，这样还不错……对JVM 的内存管理机制有加深了一层理解哈………… 下面是那篇文章，喜欢的可以看看…………O(∩_∩)O………… Java的堆是一个运行时数据区，类的实例(对象)从中分配空间。Java虚拟机(JVM)的堆中储存着正在运行的应用程序所建立的所有对象，这些对象通过new、newarray、anewarray和multianewarray等指令建立， 但是它们不需要程序代码来显式地释放。 引言 Java的堆是一个运行时数据区，类的实例(对象)从中分配空间。Java虚拟机(JVM)的堆中储存着正在运行的应用程序所建立的所有对象，这些对象通过new、newarray、anewarray和multianewarray等指令建立，但是它们不需要程序代码来显式地释放。一般来说，堆的是由垃圾回收来负责的，尽管JVM规范并不要求特殊的垃圾回收技术，甚至根本就不需要垃圾回收，但是由于内存的有限性，JVM在实现的时候都有一个由垃圾回收所管理的堆。垃圾回收是一种动态存储管理技术，它自动地释放不再被程序引用的对象，按照特定的垃圾收集算法来实现资源自动回收的功能。 垃圾收集的意义 在C++中，对象所占的内存在程序结束运行之前一直被占用，在明确释放之前不能分配给其它对象；而在Java中，当没有对象引用指向原先分配给某个对象的内存时，该内存便成为垃圾。JVM的一个系统级线程会自动释放该内存块。垃圾收集意味着程序不再需要的对象是"无用信息"，这些信息将被丢弃。当一个对象不再被引用的时候，内存回收它占领的空间，以便空间被后来的新对象使用。事实上，除了释放没用的对象，垃圾收集也可以清除内存记录碎片。由于创建对象和垃圾收集器释放丢弃对象所占的内存空间，内存会出现碎片。碎片是分配给对象的内存块之间的空闲内存洞。碎片整理将所占用的堆内存移到堆 的一端，JVM将整理出的内存分配给新的对象。 垃圾收集能自动释放内存空间，减轻编程的负担。这使Java 虚拟机具有一些优点。首先，它能使编程效率提高。在没有垃圾收集机制的时候，可能要花许多时间来解决一个难懂的存储器问题。在用Java 语言编程的时候，靠垃圾收集机制可大大缩短时间。其次是它保护程序的完整性，垃圾收集是Java语言 安全性策略的一个重要部份。 垃圾收集的一个潜在的缺点是它的开销影响程序性能。Java虚拟机必须追踪运行程序中有用的对象，而且最终释放没用的对象。这一个过程需要花费处理器的时间。其次垃圾收集算法的不完备性，早先采用的某些垃圾收集算法就不能保证100%收集到所有的废弃内存。当然随着垃圾收集算法的不断改进以及软硬件运行效率的不断提升，这些问题都可以迎刃而解。 垃圾收集的算法分析
浅谈JAVA垃圾回收机制 摘要：垃圾回收机制是JAVA的主要特性之一，在对垃圾回收机制进行概述之后，本文从“失去引用”和“离开作用域”这两个角度分析了JAVA程序中的对象在何种条件下满足垃圾回收的要求。最后，本文简要介绍了垃圾回收机制的两个特性。 关键词：JAVA；垃圾回收机制；离开作用域；失去引用；自动性；不可预期性 作为一种适应于Internet计算环境、面向对象并具有平台无关性的编程语言，JAVA早已确立了在IT界的地位，并因网络日益广泛的应用而变得越来越重要。因此，在高校中JAVA也逐渐受到更多教师和学生的重视。 实际上，JAVA源自C++语言。但JAVA语言避免了C++中晦涩的结构，成功翻越了多重继承机制的恼人问题；JAVA的垃圾回收机制显著地提高了生产率，降低了复杂度；在网络背景下使用虚拟机，以及有关安全性和动态加载的一系列设计选择，迎合了正在出现的需求和愿望。这些特性使Java不仅成为现有程序员的武器，而且也为新的程序员创造了繁荣的市场空间。在JAVA语言的上述特性中，本文主要分析其垃圾回收机制。 一、JAVA垃圾回收机制概述 在VB、C++等某些程序设计语言中，无论是对象还是动态配置的资源或内存，都必须由程序员自行声明产生和回收，否则其中的资源将不断消耗，造成资源的浪费甚至死机。由于要预先确定占用的内存空间是否应该被回收是非常困难的，这就导致手工回收内存往往是一项复杂而艰巨的工作。因此，当使用这些程序设计语言编程时，程序员不仅要考虑如何实现算法以满足应用，还要花费许多精力考虑合理使用内存避免系统崩溃。 针对这种情况，JAVA语言建立了垃圾回收机制。JAVA是纯粹的面向对象的编程语言，其程序以类为单位，程序运行期间会在内存中创建很多类的对象。这些对象在完成任务之后，JAVA 的垃圾回收机制会自动释放这些对象所占用的空间，使回收的内存能被再次利用，提高程序的运行效率。垃圾回收不仅可以提高系统的可靠性、使内存管理与类接口设计分离，还可以使开发者减少了跟踪内存管理错误的时间，从而把程序员从手工回收内存空间的繁重工作中解脱出来。 JAVA垃圾回收机制另一个特点是，进行垃圾回收的线程是一种低优先级的线程，在一个Java 程序的生命周期中，它只有在内存空闲的时候才有机会运行。 下面本文从“对象的失去引用”和“对象离开作用域”这两个方面进行分析，探讨JAVA程序中的对象什么时候可以被当作垃圾来进行回收。 二、对象的失去引用 通过下面的一段JAVA程序（例1），我们可以讨论程序中的对象是否已经符合垃圾回收的条
上次讲到引用类型和基本类型由于内存分配上的差异导致的性能问题。那么今天就来聊一下和内存释放（主要是gc）有关的话题。 事先声明一下：虽说sun公司已经被oracle吞并了，但是出于习惯，同时也为了偷懒节省打字，以下仍然称之为sun公司。 ★jvm的内存 在java虚拟机规范中（具体章节请看“这里”），提及了如下几种类型的内存空间： ◇栈内存（stack）：每个线程私有的。 ◇堆内存（heap）：所有线程公用的。 ◇方法区（method area）：有点像以前常说的“进程代码段”，这里面存放了每个加载类的反射信息、类函数的代码、编译时常量等信息。 ◇原生方法栈（native method stack）：主要用于jni中的原生代码，平时很少涉及。 关于栈内存（stack）和堆内存（heap），已经在上次的帖子中扫盲过了，大伙儿应该有点印象。由于今天咱们要讨论的“垃圾回收”话题，主要是和堆内存（heap）有关。其它的几个玩意儿不是今天讨论的重点。等以后有空了，或许可以单独聊一下。 ★垃圾回收机制简介 其实java虚拟机规范中并未规定垃圾回收的相关细节。垃圾回收具体该怎么搞，完全取决于各个jvm的设计者。所以，不同的jvm之间，gc的行为可能会有一定的差异。下面咱拿sun官方的jvm来简单介绍一下gc的机制。 ◇啥时候进行垃圾回收？ 一般情况下，当jvm发现堆内存比较紧张、不太够用时，它就会着手进行垃圾回收工作。但是大伙儿要认清这样一个残酷的事实：jvm进行gc的时间点是无法准确预知的。因为gc启动的时刻会受到各种运行环境因素的影响，随机性太大。 虽说咱们无法准确预知，但如果你想知道每次垃圾回收执行的情况，还是蛮方便的。可以通过jvm的命令行参数“-xx:+printgc”把相关信息打印出来。 另外，调用system.gc()只是建议jvm进行gc。至于jvm到底会不会做，那就不好说啦。通常不建议自己手动调用system.gc()，还是让jvm自行决定比较好。另外，使用jvm命令行参数“-xx:+disableexplicitgc”可以让system.gc()不起作用。 ◇谁来负责垃圾回收？ 一般情况下，jvm会有一个或多个专门的垃圾回收线程，由它们负责清理回收垃圾内存。 ◇如何发现垃圾对象？ 垃圾回收线程会从“根集（root set）”开始进行对象引用的遍历。所谓的“根集”，就是正在运行的线程中，可以访问的引用变量的集合（比如所有线程当前函数的参数和局部变量、当前类的成员变量等等）。垃圾回收线程先找出被根集直接引用的所有对象（不妨叫集合1），然后再找出被集合1直接引用的所有对象（不妨叫集合2），然后再找出被集合2直接引用的所有对象......如此循环往复，直到把能遍历到的对象都遍历完。 凡是从根集通过上述遍历可以到达的对象，都称为可达对象或有效对象；反之，则是不可达对象或失效对象（也就是垃圾）。 ◇如何清理/回收垃圾？ 通过上述阶段，就把垃圾对象都找出来。然后垃圾回收线程会进行相应的清理和回收工作，包括：把垃圾内存重新变为可用内存、进行内存的整理以消除内存碎片、等等。这个过程会涉及到若干算法，有兴趣的同学可以参见“这里”。限于篇幅，咱就不深入聊了。 ◇分代 早期的jvm是不采用分代技术的，所有被gc管理的对象都存放在同一个堆里面。这么做的缺点比较明显：每次进行gc都要遍历所有对象，开销很大。其实大部分的对象生命周期都很短（短命对象），只有少数对象比较长寿；在这些短命对象中，又只有少数对象占用的内存空间大；其它大量的短命对象都属于小对象（很符合二八原理）。 有鉴于此，从jdk 1.2之后，jvm开始使用分代的垃圾回收（generational garbage collection）。jvm把gc相关的内存分为年老代（tenured）和年轻代（nursery）、持久代（permanent，对应于jvm规范的方法区）。大部分对象在刚创建时，都位于年轻代。如果某对象经历了几轮gc还活着（大龄对象），就把它移到年老代。另外，如果某个对象在创建时比较大，可能就直接被丢到年老代。经过这种策略，使得年轻代总是保存那些短命的小对象。在空间尺寸上，年轻代相对较小，而年老代相对较大。 因为有了分代技术，jvm的gc也相应分为两种：主要收集（major collection）和次要收集（minor collection）。主要收集同时清理年老代和年轻代，因此开销很大，不常进行；次要收集仅仅清理年轻代，开销很小，经常进行。 ★gc对性能会有啥影响？ 刚才介绍了gc的大致原理，那gc对性能会造成哪些影响捏？主要有如下几个方面： ◇造成当前运行线程的停顿 早期的gc比较弱智。在它工作期间，所有其它的线程都被暂停（以免影响垃圾回收工作）。等到gc干完活，其它线程再继续运行。所以，早期jdk的gc一旦开始工作，整个程序就会陷入假死状态，失去各种响应。
JAVA的垃圾回收机制探究 摘要：垃圾回收机制是java的主要特性之一，在对垃圾回收机制的意义进行概述之后，文章分析了java程序中的对象在何种条件下满足垃圾回收的要求以及在垃圾回收中应该注意的几个问题。 关键词：java；垃圾回收机制 中图分类号：tp312文献标识码：a文章编号：1007-9599 (2011) 24-0000-01 java garbage collection mechanism study wang xin (daqing petroleum administration communications company,daqing163453,china) abstract:java garbage collection mechanism is one of the main features of the garbage collection mechanism for an overview of the meaning,the paper analyzes the objects in the java program to meet the conditions under which the requirements of garbage collection and garbage collection should be noted a few questions. keywords:java;garbage collection mechanism 一、垃圾收集的意义 在c++中，对象所占的内存在程序结束运行之前一直被占用，在明确释放之前不能分配给其它对象；而在java中，当没有对象引用指向原先分配给某个对象的内存时，该内存便成为垃圾。jvm的
详细介绍Java垃圾回收机制 垃圾收集GC（Garbage Collection）是Java语言的核心技术之一，之前我们曾专门探讨过Java 7新增的垃圾回收器G1的新特性，但在JVM的内部运行机制上看，Java的垃圾回收原理与机制并未改变。垃圾收集的目的在于清除不再使用的对象。GC通过确定对象是否被活动对象引用来确定是否收集该对象。GC首先要判断该对象是否是时候可以收集。两种常用的方法是引用计数和对象引用遍历。 引用计数收集器 引用计数是垃圾收集器中的早期策略。在这种方法中，堆中每个对象（不是引用都一个引用计数。当一个对象被创建时，且将该对象分配给一个变量，该变量计数设置为1。当任何其它变量被赋值为这个对象的引用时，计数加1（a = b,则b 引用的对象+1），但当一个对象的某个引用超过了生命周期或者被设置为一个新值时，对象的引用计数减1。任何引用计数为0的对象可以被当作垃圾收集。当一个对象被垃圾收集时，它引用的任何对象计数减1。 优点：引用计数收集器可以很快的执行，交织在程序运行中。对程序不被长时间打断的实时环境比较利。 缺点：无法检测出循环引用。如父对象有一个对子对象的引用，子对象反过来引用父对象。这样，他们的引用计数永远不可能为0. 跟踪收集器 早期的JVM使用引用计数，现在大多数JVM采用对象引用遍历。对象引用遍历从一组对象开始，沿着整个对象图上的每条链接，递归确定可到达（reachable）的对象。如果某对象不能从这些根对象的一个（至少一个）到达，则将它作为垃圾收集。在对象遍历阶段，GC必须记住哪些对象可以到达，以便删除不可到达的对象，这称为标记（marking）对象。 下一步，GC要删除不可到达的对象。删除时，有些GC只是简单的扫描堆栈，删除未标记的未标记的对象，并释放它们的内存以生成新的对象，这叫做清除（sweeping）。这种方法的问题在于内存会分成好多小段，而它们不足以用于新的对象，但是组合起来却很大。因此，许多GC可以重新组织内存中的对象，并进行压缩（compact），形成可利用的空间。
一．谁在做Garbage Collection？ 一种流行的说法：在C++里，是系统在做垃圾回收；而在Java里，是Java自身在做。 在C++里，释放内存是手动处理的，要用delete运算符来释放分配的内存。这是流行的说法。确切地说，是应用认为不需要某实体时，就需用delete 告诉系统，可以回收这块空间了。这个要求，对编码者来说，是件很麻烦、很难做到的事。随便上哪个BBS，在C/C++版块里总是有一大堆关于内存泄漏的话题。 Java采用一种不同的，很方便的方法：Garbage Collection。垃圾回收机制放在JVM里。JVM完全负责垃圾回收事宜，应用只在需要时申请空间，而在抛弃对象时不必关心空间回收问题。 二．对象在啥时被丢弃？ 在C++里，当对象离开其作用域时，该对象即被应用抛弃。 在Java里，对象的生命期不再与其作用域有关，而仅仅与引用有关。 Java的垃圾回收机制一般包含近十种算法。对这些算法中的多数，我们不必予以关心。只有其中最简单的一个：引用计数法，与编码有关。 一个对象，可以有一个或多个引用变量指向它。当一个对象不再有任何一个引用变量指向它时，这个对象就被应用抛弃了。或者说，这个对象可以被垃圾回收机制回收了。这就是说，当不存在对某对象的任何引用时，就意味着，应用告诉JVM：我不要这个对象，你可以回收了。 JVM的垃圾回收机制对堆空间做实时检测。当发现某对象的引用计数为0时，就将该对象列入待回收列表中。但是，并不是马上予以销毁。 三．丢弃就被回收？ 该对象被认定为没有存在的必要了，那么它所占用的内存就可以被释放。被回收的内存可以用于后续的再分配。 但是，并不是对象被抛弃后当即被回收的。JVM进程做空间回收有较大的系统开销。如果每当某应用进程丢弃一个对象，就立即回收它的空间，势必会使整个系统的运转效率非常低下。前面说过，JVM的垃圾回收机制有多个算法。除了引用计数法是用来判断对象是否已被抛弃外，其它算法是用来确定何时及如何做回收。 JVM的垃圾回收机制要在时间和空间之间做个平衡。 因此，为了提高系统效率，垃圾回收器通常只在满足两个条件时才运行：即有对象要回收且系统需要回收。切记垃圾回收要占用时间，因此，Java
java垃圾回收机制是怎样的 手动管理内存 在介绍现代版的垃圾回收之前，我们先来简单地回顾下需要手 动地显式分配及释放内存的那些日子。如果你忘了去释放内存，那么这块内存就无法重用了。这块内存被占有了却没被使用。这种场景被称之为内存泄露。 下面是用C写的一个手动管理内存的简单例子： intsend_request() { size_tn=read_size(); int*elements=malloc(n*sizeof(int)); if(read_elements(n,elements) 11intsend_request(){size_tn=read_size();stared_ptrelements= make_shared();if(read_elements(n,elements) Java 中的堆和栈 简单的说： Java把内存划分成两种：一种是栈内存，一种是堆内存。 在函数中定义的一些基本类型的变量和对象的引用变量都在函数的栈内存中分配。 当在一段代码块定义一个变量时，Java就在栈中为这个变量分配内存空间，当超过变量的作用域后，Java会自动释放掉为该变量所分配的内存空间，该内存空间可以立即被另作他用。 堆内存用来存放由new创建的对象和数组。 在堆中分配的内存，由Java虚拟机的自动垃圾回收器来管理。 在堆中产生了一个数组或对象后，还可以在栈中定义一个特殊的变量，让栈中这个变量的取值等于数组或对象在堆内存中的首地址，栈中的这个变量就成了数组或对象的引用变量。 引用变量就相当于是为数组或对象起的一个名称，以后就可以在程序中使用栈中的引用变量来访问堆中的数组或对象。 具体的说： 栈与堆都是Java用来在Ram中存放数据的地方。与C++不同，Java自动管理栈和堆，程序员不能直接地设置栈或堆。 Java的堆是一个运行时数据区,类的(对象从中分配空间。这些对象通过new、newarray、anewarray和multianewarray等指令建立，它们不需要程序代码来显式的释放。堆是由垃圾回收来负责的，堆的优势是可以动态地分配内存大小，生存期也不必事先告诉编译器，因为它是在运行时动态分配内存的，Java的垃圾收集器会自动收走这些不再使用的数据。但缺点是，由于要在运行时动态分配内存，存取速度较慢。 栈的优势是，存取速度比堆要快，仅次于寄存器，栈数据可以共享。但缺点是，存在栈中的数据大小与生存期必须是确定的，缺乏灵活性。栈中主要存放一些基本类型的变量（,int, short, long, byte, float, double, boolean, char）和对象句柄。 栈有一个很重要的特殊性，就是存在栈中的数据可以共享。假设我们同时定义： int a = 3; int b = 3； 编译器先处理int a = 3；首先它会在栈中创建一个变量为a的引用，然后查找栈中是否有3这个值，如果没找到，就将3存放进来，然后将a指向3。接着处理int b = 3；在创建完b的引用变量后，因为在栈中已经有3这个值，便将b直接指向3。这样，就出现了a与b同时均指向3的情况。这时，如果再令a=4；那么编译器会重新搜索栈中是否有4值，如果没有，则将4存放进来，并令a指向4；如果已经有了，则直接将a指向这个地址。因此a值的改变不会影响到b 的值。要注意这种数据的共享与两个对象的引用同时指向一个对象的这种共享是不同的，因为这种情况a的修改并不会影响到b, 它是由编译器完成的，它有利于节省空间。而一个对象引用变量修改了这个对象的内部状态，会影响到另一个对象引用变量。 String是一个特殊的包装类数据。可以用： String str = new String("abc"); String str = "abc"; 两种的形式来创建，第一种是用new()来新建对象的，它会在存放于堆中。每调用一次就会创建一个新的对象。 而第二种是先在栈中创建一个对String类的对象引用变量str，然后查找栈中有没有存放"abc"，如果没有，则将"abc"存放进栈，并令str指向”abc”，如果已经有”abc”则直接令 str指向“abc”。 比较类里面的数值是否相等时，用equals()方法；当测试两个包装类的引用是否指向同一个对象时，用==，下面用例子说明上面的理论。 String str1 = "abc"; String str2 = "abc"; System.out.println(str1==str2); //true JVM调优总结 作者: 和你在一起https://www.doczj.com/doc/09306378.html, 程序员其实很痛苦的，每隔一段时间就会听到、看到很多很多新名词、新技术---囧.幸而有了互联网，有了开源、有了wiki、有了分享：）—人人为我，我为人人。拓荒者走过的时候很痛苦，但是如果能给后来人留下点路标，是不是可以让他们少走一些弯路呢？踏着前辈的足迹我走到了这里，也应该为后来的人留下点东西。走夜路其实不可怕，可怕的是一个人走夜路：）https://www.doczj.com/doc/09306378.html, - 做最棒的软件开发交流社区 A-PDF Number Pro DEMO: Purchase from https://www.doczj.com/doc/09306378.html, to remove the watermark 目 录 1. java路上 1.1 JVM调优总结-序 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .3 1.2 JVM调优总结（一）-- 一些概念 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .4 1.3 JVM调优总结（二）-一些概念 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .7 1.4 JVM调优总结（三）-基本垃圾回收算法 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .9 1.5 JVM调优总结（四）-垃圾回收面临的问题 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .12 1.6 JVM调优总结（五）-分代垃圾回收详述1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .14 1.7 JVM调优总结（六）-分代垃圾回收详述2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .18 1.8 JVM调优总结（七）-典型配置举例1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .26 1.9 JVM调优总结（八）-典型配置举例2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .31 1.10 JVM调优总结（九）-新一代的垃圾回收算法 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .34 1.11 JVM调优总结（十）-调优方法 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .38 1.12 JVM调优总结（十一）-反思 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .47 1.13 JVM调优总结（十二）-参考资料 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .50 JVM内存管理：深入垃圾收集器与内存分配策略 https://www.doczj.com/doc/09306378.html, 时间：2010-11-20 作者：网络编辑：fnw 点击： 6 [ 评论] - - Java与C++之间有一堵由内存动态分配和垃圾收集技术所围成的高墙，墙外面的人想进去，墙里面的人却想出来。 概述： 说起垃圾收集（Garbage Collection，下文简称GC），大部分人都把这项技术当做Java 语言的伴生产物。事实上GC的历史远远比Java来得久远，在1960年诞生于MIT的Lisp 是第一门真正使用内存动态分配和垃圾收集技术的语言。当Lisp还在胚胎时期，人们就在思考GC需要完成的3件事情：哪些内存需要回收？什么时候回收？怎么样回收？ 经过半个世纪的发展，目前的内存分配策略与垃圾回收技术已经相当成熟，一切看起来都进入“自动化”的时代，那为什么我们还要去了解GC和内存分配？答案很简单：当需要排查各种内存溢出、泄漏问题时，当垃圾收集成为系统达到更高并发量的瓶颈时，我们就需要对这些“自动化”的技术有必要的监控、调节手段。 把时间从1960年拨回现在，回到我们熟悉的Java语言。本文第一章中介绍了Java内存运行时区域的各个部分，其中程序计数器、VM栈、本地方法栈三个区域随线程而生，随线程而灭；栈中的帧随着方法进入、退出而有条不紊的进行着出栈入栈操作；每一个帧中分配多少内存基本上是在Class文件生成时就已知的（可能会由JIT动态晚期编译进行一些优化，但大体上可以认为是编译期可知的），因此这几个区域的内存分配和回收具备很高的确定性，因此在这几个区域不需要过多考虑回收的问题。而Java堆和方法区（包括运行时常量池）则不一样，我们必须等到程序实际运行期间才能知道会创建哪些对象，这部分内存的分配和回收都是动态的，我们本文后续讨论中的“内存”分配与回收仅仅指这一部分内存。 对象已死？ 在堆里面存放着Java世界中几乎所有的对象，在回收前首先要确定这些对象之中哪些还在存活，哪些已经“死去”了，即不可能再被任何途径使用的对象。 引用计数算法（Reference Counting） 最初的想法，也是很多教科书判断对象是否存活的算法是这样的：给对象中添加一个引用计数器，当有一个地方引用它，计数器加1，当引用失效，计数器减1，任何时刻计数器为0的对象就是不可能再被使用的。 客观的说，引用计数算法实现简单，判定效率很高，在大部分情况下它都是一个不错的算法，但引用计数算法无法解决对象循环引用的问题。举个简单的例子：对象A和B分别有字段b、a，令A.b=B和B.a=A，除此之外这2个对象再无任何引用，那实际上这2个对 Java垃圾回收机制 1、引用计数：没有应用到JVM，只是理论说明。 2、活的对象：可以追溯到堆栈和静态存储区 3、Stop and copy：停止工作，将活的对象从一个堆复制到另一个堆，紧密排列，然后剩下 的就是垃圾对象了。问题：（1）空间；（2）复制：垃圾少，要复制大量活的对象 4、Mark and sweep：标记每个对象是否活对象，标记完所有对象，清楚非活的对象。问题： 空间不连续。 5、如果垃圾很少，复制效率降低的话就用，标记清扫；如果不连续空间太多的话，则转到 停止复制 6、优化方法：Just－In-Time 和HotSoft，前者翻译成本地机器码，后者惰性编译，只在必 要时编译代码，不被执行的代码不被编译，代码每次执行的时候都会做一定的优化。7、避免内存泄漏或者不当使用的方法：（1）重复使用已经初始化的对象，尽量少声明对象； （2）try catch finally语句中清楚不需要的对象；(3)执行完毕清楚不必要的对象，当然是那些引用可能被保存的对象。 尽管java虚拟机和垃圾回收机制管理着大部分的内存事务，但是在java软件中还是可能存在内存泄漏的情况。的确，在大型工程中，内存泄漏是一个普遍问题。避免内存泄漏的第一步，就是要了解他们发生的原因。这篇文章就是要介绍一些常见的缺陷，然后提供一些非常好的实践例子来指导你写出没有内存泄漏的代码。一旦你的程序存在内存泄漏，要查明代码中引起泄漏的原因是很困难的。同时这篇文章也要介绍一个新的工具来查找内存泄漏，然后指明发生的根本原因。这个工具容易上手，可以让你找到产品级系统中的内存泄漏。 垃圾回收（GC）的角色 虽然垃圾回收关心着大部分的问题，包括内存管理，使得程序员的任务显得更加轻松，但是程序员还是可能犯些错误导致内存泄漏问题。GC(垃圾回收)通过递归对所有从“根”对象(堆栈中的对象，静态数据成员，JNI句柄等等)继承下来的引用进行工作，然后标记所有可以访问的活动着的对象。而这些对象变成了程序唯一能够操纵的对象，其他的对象都被释放了。因为GC使得程序不能够访问那些被释放的对象，所以这样做是安全的。 内存管理可以说是自动的，但是这并没有让程序员脱离内存管理问题。比方说，对于内存的分配（还有释放）总是存在一定的开销，尽管这些开销对程序员来说是隐含的。一个程序如果创建了很多对象，那么它就要比完成相同任务而创建了较少对象的程序执行的速度慢（如果其他的条件都相同）。 JVM详解 本文详细讲解了JVM(Java Virtual Machine)的方方面面,首先由java的特性来描绘JVM 的大致应用,再细细阐述了JVM的原理及内存管理机制和调优.最后讲述了与JVM密切相关的Java GC机制. 本文内容大多来自网络,但内容十分丰富,是学习JVM的好资料. 后面会再针对JVM的两大职责class loader和execution engine进行讲解 若有疑问 垃圾收集GC（Garbage Collection）是Java语言的核心技术之一，之前我们曾专门探讨过Java 7新增的垃圾回收器G1的新特性，但在JVM的内部运行机制上看，Java的垃圾回收原理与机制并未改变。垃圾收集的目的在于清除不再使用的对象。GC通过确定对象是否被活动对象引用来确定是否收集该对象。GC首先要判断该对象是否是时候可以收集。两种常用的方法是引用计数和对象引用遍历。 引用计数收集器 引用计数是垃圾收集器中的早期策略。在这种方法中，堆中每个对象（不是引用）都有一个引用计数。当一个对象被创建时，且将该对象分配给一个变量，该变量计数设置为1。当任何其它变量被赋值为这个对象的引用时，计数加1（a = b,则b引用的对象+1），但当一个对象的某个引用超过了生命周期或者被设置为一个新值时，对象的引用计数减1。任何引用计数为0的对象可以被当作垃圾收集。当一个对象被垃圾收集时，它引用的任何对象计数减1。 优点：引用计数收集器可以很快的执行，交织在程序运行中。对程序不被长时间打断的实时环境比较有利。 缺点：无法检测出循环引用。如父对象有一个对子对象的引用，子对象反过来引用父对象。这样，他们的引用计数永远不可能为0. 跟踪收集器 早期的JVM使用引用计数，现在大多数JVM采用对象引用遍历。对象引用遍历从一组对象开始，沿着整个对象图上的每条链接，递归确定可到达（reachable）的对象。如果某对象不能从这些根对象的一个（至少一个）到达，则将它作为垃圾收集。在对象遍历阶段，GC必须记住哪些对象可以到达，以便删除不可到达的对象，这称为标记（marking）对象。 下一步，GC要删除不可到达的对象。删除时，有些GC只是简单的扫描堆栈，删除未标记的未标记的对象，并释放它们的内存以生成新的对象，这叫做清除（sweeping）。这种方法的问题在于内存会分成好多小段，而它们不足以用于新的对象，但是组合起来却很大。因此，许多GC可以重新组织内存中的对象，并进行压缩（compact），形成可利用的空间。 为此，GC需要停止其他的活动活动。这种方法意味着所有与应用程序相关的工作停止，只有GC运行。结果，在响应期间增减了许多混杂请求。另外，更复杂的GC不断增加或同时运行以减少或者清除应用程序的中断。有的GC使用单线程完成这项工作，有的则采用多线程以增加效率。 一些常用的垃圾收集器 （1）标记－清除收集器 1、在java中如果声明一个类为final，表示什么意思？ 答：final是最终的意思，final可用于定义变量、方法和类但含义不同，声明为final的类不能被继承。 2、父类的构造方法是否可以被子类覆盖（重写）？ 答：父类的构造方法不可以被子类覆盖，因为父类和子类的类名是不可能一样的。 3、请讲述String和StringBuffer的区别。 答：String类所定义的对象是用于存放“长度固定”的字符串。 StringBuffer类所定义的对象是用于存放“长度可变动”的字符串。 4、如果有两个类A、B（注意不是接口），你想同时使用这两个类的功能，那么你会如何编写这个C类呢？ 答：因为类A、B不是接口，所以是不可以直接继承的，但可以将A、B类定义成父子类，那么C类就能实现A、B类的功能了。假如A为B的父类，B为C的父类，此时C就能实现A、B的功能。 5、结合Java视频Lesson5（多线程），分析sleep()和wait()方法的区别。 答：Sleeping睡眠的意思:sleep()方法用来暂时中止执行的线程。在睡眠后，线程将进入就绪状态。 waiting等待的意思:如果调用了wait()方法，线程将处于等待状态。用于在两个或多个线程并发运行时。 6、谈谈你对抽象类和接口的理解。 答：定义抽象类的目的是提供可由其子类共享的一般形式、子类可以根据自身需要扩展抽象类、抽象类不能实例化、抽象方法没有函数体、抽象方法必须在子类中给出具体实现。他使用extends 来继承。 接口：一个接口允许一个类从几个接口继承而来，Java程序一次只能继承一个类但可以实现几个接口，接口不能有任何具体的方法，接口也可用来定义可由类使用的一组常量。其实现方式是interface来实现。 7.Java的接口和C++的虚类的相同和不同处。 由于Java不支持多继承，而有可能某个类或对象要使用分别在几个类或对象里面的方法或属性，现有的单继承机制就不能满足要求。与继承相比，接口有更高的灵活性，因为接口中没有任何 垃圾回收回收的是无任何引用的对象占据的内存空间而不是对象本身 一个对象在运行时，可能会有一些东西与其关连，因此，当对象即将销毁时，有时需要做一些善后工作，可以把这些操作写在finalize()方法（常称之为终止器）。 protected void finalize(){ // code here } 这个终止器的用途类似于C++里的析构函数，而且都是自动调用的，但是，两者的调用时机不一样，使两者的表现行为有重大区别。C++的析构函数总是当对象离开作用域时被调用。这就是说，C++析构函数的调用时机是确定的，且是被应用判知的，但是，JAVA终止器却是在对象被销毁时调用，一旦垃圾收集器准备好释放无用对象占用的存储空间，它首先调用那些对象的finalize()方法，然后才真正回收对象的内在。 我们知道，许多程序设计语言都允许在程序运行期动态地分配内存空间。分配内存的方式多种多样，取决于该种语言的语法结构。但不论是哪一种语言的内存分配方式，最后都要返回所分配的内存块的起始地址，即返回一个指针到内存块的首地址。 当已经分配的内存空间不再需要时，换句话说当指向该内存块的句柄超出了使用范围的时候，该程序或其运行环境就应该回收该内存空间，以节省宝贵的内存资源。 在C，C++或其他程序设计语言中，无论是对象还是动态配置的资源或内存，都必须由程序员自行声明产生和回收，否则其中的资源将消耗，造成资源的浪费甚至死机。但手工回收内存往往是一项复杂而艰巨的工作。因为要预先确定占用的内存空间是否应该被回收是非常困难的！如果一段程序不能回收内存空间，而且在程序运行时系统中又没有了可以分配的内存空间时，这段程序就只能崩溃。通常，我们把分配出去后，却无法回收的内存空间称为"内存渗漏体（Memory Leaks）"。 以上这种程序设计的潜在危险性在Java这样以严谨、安全著称的语言中是不允许的。但是Java语言既不能限制程序员编写程序的自由性，又不能把声明对象的部分去除（否则就不是面向对象的程序语言了），那么最好的解决办法就是从Java程序语言本身的特性入手。于是，Java技术提供了一个系统级的线程（Thread），即垃圾收集器线程（Garbage Collection Thread），来跟踪每一块分配出去的内存空间，当Java 虚拟机（Java Virtual Machine）处于空闲循环时，垃圾收集器线程会自动检查每一快分配出去的内存空间，然后自动回收每一快可以回收的无用的内存块。 垃圾收集器线程是一种低优先级的线程，在一个Java程序的生命周期中，它只有在内存空闲的时候才有机会运行。它有效地防止了内存渗漏体的出现，并极大可能地节省了宝贵的内存资源。但是，通过Java虚拟机来执行垃圾收集器的方案可以是多种多样的。 下面介绍垃圾收集器的特点和它的执行机制： 垃圾收集器系统有自己的一套方案来判断哪个内存块是应该被回收的，哪个是不符合要求暂不回收的。垃圾收集器在一个Java程序中的执行是自动的，不能强制执行，即使程序员能JVM内存分配(栈堆)与JVM回收机制
JVM调优总结
JVM内存管理：深入垃圾收集器与内存分配策略
Java垃圾回收机制
JVM详解
Java垃圾回收机制
Java试题及答案
java垃圾回收机制总结
相关主题
文本预览