① java有哪些垃圾回收算法
常用的垃圾回收算法有：
(1).引用计数算法：
给对象中添加一个引用计数器，每当有一个地方引用它时，计数器值就加1；当引用失效时，计数器值就减1；任何时刻计数器都为0的对象就是不再被使用的，垃圾收集器将回收该对象使用的内存。
引用计数算法实现简单，效率很高，微软的COM技术、ActionScript、Python等都使用了引用计数算法进行内存管理，但是引用计数算法对于对象之间相互循环引用问题难以解决，因此java并没有使用引用计数算法。
(2).根搜索算法：
通过一系列的名为“GC Root”的对象作为起点，从这些节点向下搜索，搜索所走过的路径称为引用链(Reference Chain)，当一个对象到GC Root没有任何引用链相连时，则该对象不可达，该对象是不可使用的，垃圾收集器将回收其所占的内存。
主流的商用程序语言C#、java和Lisp都使用根搜素算法进行内存管理。
在java语言中，可作为GC Root的对象包括以下几种对象：
a. java虚拟机栈(栈帧中的本地变量表)中的引用的对象。
b.方法区中的类静态属性引用的对象。
c.方法区中的常量引用的对象。
d.本地方法栈中JNI本地方法的引用对象。
java方法区在Sun HotSpot虚拟机中被称为永久代，很多人认为该部分的内存是不用回收的，java虚拟机规范也没有对该部分内存的垃圾收集做规定，但是方法区中的废弃常量和无用的类还是需要回收以保证永久代不会发生内存溢出。
判断废弃常量的方法：如果常量池中的某个常量没有被任何引用所引用，则该常量是废弃常量。
判断无用的类：
(1).该类的所有实例都已经被回收，即java堆中不存在该类的实例对象。
(2).加载该类的类加载器已经被回收。
(3).该类所对应的java.lang.Class对象没有任何地方被引用，无法在任何地方通过反射机制访问该类的方法。
Java中常用的垃圾收集算法：
(1).标记-清除算法：
最基础的垃圾收集算法，算法分为“标记”和“清除”两个阶段：首先标记出所有需要回收的对象，在标记完成之后统一回收掉所有被标记的对象。
标记-清除算法的缺点有两个：首先，效率问题，标记和清除效率都不高。其次，标记清除之后会产生大量的不连续的内存碎片，空间碎片太多会导致当程序需要为较大对象分配内存时无法找到足够的连续内存而不得不提前触发另一次垃圾收集动作。
(2).复制算法：
将可用内存按容量分成大小相等的两块，每次只使用其中一块，当这块内存使用完了，就将还存活的对象复制到另一块内存上去，然后把使用过的内存空间一次清理掉。这样使得每次都是对其中一块内存进行回收，内存分配时不用考虑内存碎片等复杂情况，只需要移动堆顶指针，按顺序分配内存即可，实现简单，运行高效。
复制算法的缺点显而易见，可使用的内存降为原来一半。
(3).标记-整理算法：
标记-整理算法在标记-清除算法基础上做了改进，标记阶段是相同的标记出所有需要回收的对象，在标记完成之后不是直接对可回收对象进行清理，而是让所有存活的对象都向一端移动，在移动过程中清理掉可回收的对象，这个过程叫做整理。
标记-整理算法相比标记-清除算法的优点是内存被整理以后不会产生大量不连续内存碎片问题。
复制算法在对象存活率高的情况下就要执行较多的复制操作，效率将会变低，而在对象存活率高的情况下使用标记-整理算法效率会大大提高。
(4).分代收集算法：
根据内存中对象的存活周期不同，将内存划分为几块，java的虚拟机中一般把内存划分为新生代和年老代，当新创建对象时一般在新生代中分配内存空间，当新生代垃圾收集器回收几次之后仍然存活的对象会被移动到年老代内存中，当大对象在新生代中无法找到足够的连续内存时也直接在年老代中创建。
② 什么是Java的垃圾回收机制内部实现原理是什么
Java中的对象没有作用域的概念，只有对象的引用才有作用域。在用new创建出一个对象之后，垃圾回收器就会自动监控该对象，并且会辨别是否需要释放内存，不需要开发者手动释放，所以可以很好的防止内存泄漏。
JVM的垃圾回收器采用的是一种分代（generational ）回收策略，共分为三个代：
1.Young（年轻代）
年 轻代分三个区。一个Eden区，两个Survivor区。大部分对象在Eden区中生成。当Eden区满时，还存活的对象将被复制到Survivor区 （两个中的一个），当这个Survivor区满时，此区的存活对象将被复制到另外一个Survivor区，当这个Survivor去也满了的时候，从第一 个Survivor区复制过来的并且此时还存活的对象，将被复制“年老区(Tenured)”。需要注意，Survivor的两个区是对称的，没先后关 系，所以同一个区中可能同时存在从Eden复制过来 对象，和从前一个Survivor复制过来的对象，而复制到年老区的只有从第一个Survivor去过来的对象。而且，Survivor区总有一个是空的。
2.Tenured（年老代）
年老代存放从年轻代存活的对象。一般来说年老代存放的都是生命期较长的对象。
3.Perm（持久代）
用 于存放静态文件，如Java类、方法等。持久代对垃圾回收没有显著影响，但是有些应用可能动态生成或者调用一些class，例如Hibernate等， 在这种时候需要设置一个比较大的持久代空间来存放这些运行过程中新增的类。持久代大小通过-XX:MaxPermSize=进行设置。
③ java中垃圾回收机制的原理
java中垃圾回收机制的原理
推荐一篇文章：
对高性能JAVA代码之内存管理
更甚者你写的代码，GC根本就回收不了，直接系统挂掉。GC是一段程序，不是智能，他只回收他认为的垃圾，而不是回收你认为的垃圾。
GC垃圾回收：
Grabage Collection相信学过JAVA的人都知道这个是什么意思。但是他是如何工作的呢？
首先，JVM在管理内存的时候对于变量的管理总是分新对象和老对象。新对象也就是开发者new出来的对象，但是由于生命周期短，那么他占用的内存并不是马上释放，而是被标记为老对象，这个时候该对象还是要存在一段时间。然后由JVM决定他是否是垃圾对象，并进行回收。
所以我们可以知道，垃圾内存并不是用完了马上就被释放，所以就会产生内存释放不及时的现象，从而降低了内存的使用。而当程序浩大的时候。这种现象更为明显，并且GC的工作也是需要消耗资源的。所以，也就会产生内存浪费。
JVM中的对象生命周期里谈内存回收：
对象的生命周期一般分为7个阶段：创建阶段，应用阶段，不可视阶段，不可到达阶段，可收集阶段，终结阶段，释放阶段。
创建阶段：首先大家看一下，如下两段代码：
test1：
for（ int i=0; i《10000; i++）
Object obj=new Object（）;
test2：
Object obj=null;
for（ int i=0; i《10000; i++）
obj=new Object（）;
这两段代码都是相同的功能，但是显然test2的性能要比test1性能要好，内存使用率要高，这是为什么呢？原因很简单，test1每次执行for循环都要创建一个Object的临时对象，但是这些临时对象由于JVM的GC不能马上销毁，所以他们还要存在很长时间，而test2则只是在内存中保存一份对象的引用，而不必创建大量新临时变量，从而降低了内存的使用。
另外不要对同一个对象初始化多次。例如：
public class A{
private Hashtable table = new Hashtable（）;
public A（）{ table = new Hashtable（）;
// 这里应该去掉，因为table已经被初始化。
}
这样就new了两个Hashtable，但是却只使用了一个。另外一个则没有被引用。而被忽略掉。浪费了内存。并且由于进行了两次new操作。也影响了代码的执行速度。
应用阶段：即该对象至少有一个引用在维护他。
不可视阶段：即超出该变量的作用域。这里有一个很好的做法，因为JVM在GC的时候并不是马上进行回收，而是要判断对象是否被其他引用在维护。所以，这个时候如果我们在使用完一个对象以后对其obj=null或者obj.doSomething（）操作，将其标记为空，可以帮助JVM及时发现这个垃圾对象。
不可到达阶段：就是在JVM中找不到对该对象的直接或者间接的引用。
可收集阶段，终结阶段，释放阶段：此为回收器发现该对象不可到达，finalize方法已经被执行，或者对象空间已被重用的时候。
JAVA的析构方法：
可能不会有人相信，JAVA有析构函数？ 是的，有。因为JAVA所有类都继承至Object类，而finalize就是Object类的一个方法，这个方法在JAVA中就是类似于C++析构函数。一般来说可以通过重载finalize方法的形式才释放类中对象。如：
public class A{
public Object a;
public A（）{ a = new Object ;}
protected void finalize（） throws java.lang.Throwable{
a = null; // 标记为空，释放对象
super.finalize（）; // 递归调用超类中的finalize方法。
}
}
当然，什么时候该方法被调用是由JVM来决定的。..。..。..。..。..。..。..。.
一般来说，我们需要创建一个destory的方法来显式的调用该方法。然后在finalize也对该方法进行调用，实现双保险的做法。
由于对象的创建是递归式的，也就是先调用超级类的构造，然后依次向下递归调用构造函数，所以应该避免在类的构造函数中初始化变量，这样可以避免不必要的创建对象造成不必要的内存消耗。当然这里也就看出来接口的优势。
数组的创建：
由于数组需要给定一个长度，所以在不确定数据数量的时候经常会创建过大，或过小的数组的现象。造成不必要的内存浪费，所以可以通过软引用的方式来告诉JVM及时回收该内存。（软引用，具体查资料）。
例如：
Object obj = new char［10000000000000000］;
SoftReference ref = new SoftReference（obj）;
共享静态存储空间：
我们都知道静态变量在程序运行期间其内存是共享的，因此有时候为了节约内存工件，将一些变量声明为静态变量确实可以起到节约内存空间的作用。但是由于静态变量生命周期很长，不易被系统回收，所以使用静态变量要合理，不能盲目的使用。以免适得其反。
因此建议在下面情况下使用：
1，变量所包含的对象体积较大，占用内存过多。
2，变量所包含对象生命周期较长。
3，变量所包含数据稳定。
4，该类的对象实例有对该变量所包含的对象的共享需求。（也就是说是否需要作为全局变量）。
对象重用与GC：
有的时候，如数据库操作对象，一般情况下我们都需要在各个不同模块间使用，所以这样的对象需要进行重用以提高性能。也有效的避免了反复创建对象引起的性能下降。
一般来说对象池是一个不错的注意。如下：
public abstarct class ObjectPool{
private Hashtable locked，unlocked;
private long expirationTime;
abstract Object create（）;
abstract void expire（ Object o）;
abstract void validate（ Object o）;
synchronized Object getObject（）{。..};
synchronized void freeObject（Object o）{。..};
这样我们就完成了一个对象池，我们可以将通过对应的方法来存取删除所需对象。来维护这快内存提高内存重用。
当然也可以通过调用System.gc（）强制系统进行垃圾回收操作。当然这样的代价是需要消耗一些cpu资源。
不要提前创建对象：
尽量在需要的时候创建对象，重复的分配，构造对象可能会因为垃圾回收做额外的工作降低性能。
JVM内存参数调优：
强制内存回收对于系统自动的内存回收机制会产生负面影响，会加大系统自动回收的处理时间，所以应该尽量避免显式使用System.gc（），
JVM的设置可以提高系统的性能。例如：
java -XX:NewSize=128m -XX:MaxNewSize=128m -XX:SurvivorRatio=8 -Xms512m -Xmx512m
具体可以查看java帮助文档。我们主要介绍程序设计方面的性能提高。
JAVA程序设计中有关内存管理的其他经验：
根据JVM内存管理的工作原理，可以通过一些技巧和方式让JVM做GC处理时更加有效。，从而提高内存使用和缩短GC的执行时间。
1，尽早释放无用对象的引用。即在不使用对象的引用后设置为空，可以加速GC的工作。（当然如果是返回值。..。.）
2，尽量少用finalize函数，此函数是JAVA给程序员提供的一个释放对象或资源的机会，但是却会加大GC工作量。
3，如果需要使用到图片，可以使用soft应用类型，它可以尽可能将图片读入内存而不引起OutOfMemory.
4，注意集合数据类型的数据结构，往往数据结构越复杂，GC工作量更大，处理更复杂。
5，尽量避免在默认构造器（构造函数）中创建，初始化大量的对象。
6，尽量避免强制系统做垃圾回收。会增加系统做垃圾回收的最终时间降低性能。
7，尽量避免显式申请数组，如果不得不申请数组的话，要尽量准确估算数组大小。
8，如果在做远程方法调用。要尽量减少传递的对象大小。或者使用瞬间值避免不必要数据的传递。
9，尽量在合适的情况下使用对象池来提高系统性能减少内存开销，当然，对象池不能过于庞大，会适得其反.
④ java中的垃圾回收是什么意思
垃圾回收就是gc（gabage collection）。
java比c++的优点就是多了垃圾回收机制，程序回员不用去答关心垃圾的回收，系统会自动调用去回收内存。
一般我们想回收的时候只需要调用system.gc方法就可以了。系统会自己去调用destroy方法和其他的回收方法释放内存，节省内存空间。
⑤ java中是怎样进行垃圾回收的
您好，提问者：
1、Java有专门一个线程负责垃圾回收机制。
2、当一个对象为null时垃圾回收线程会不定期的进行回收。
3、我们可以在程序中使用System.gc来通知JVM进行回收，如下代码：
publicclassGc_ThreadDemoextendsThread{
//重写父类的垃圾回收方法
publicvoidrun(){
for(inti=0;i<10;i++){
System.out.println(Thread.currentThread().getName());
}
}
//默认extendsObject
@Override
publicvoidfinalize(){
System.out.println(Thread.currentThread().getName()+"....垃圾回收方法运行");
}
//主方法
publicstaticvoidmain(String[]args){
Gc_ThreadDemogc=newGc_ThreadDemo();
for(inti=0;i<10;i++){
newGc_ThreadDemo();//制造匿名对象,好让JVM执行垃圾回收方法。
System.gc();//通知JVM执行垃圾回收
}
gc.start();
System.out.println(Thread.currentThread().getName());
}
}
//我们正常编译：javac-dclassesGc_ThreadDemo.java
//如果要看到JVM线程回收情况，我们可以使用：java-verbose:gc-cpclassesGc_ThreadDemo
⑥ java垃圾回收常用的两种方法是什么
java垃圾回收由java虚拟机自己调用，程序员不用管
两种方法是 System.gc()
Runtime.gc()
Java堆的管理—垃圾回收提到一下几点，很不错，或许可以作为写程序时候的准则：
（1）不要试图去假定垃圾收集发生的时间，这一切都是未知的。比如，方法中的一个临时对象在方法调用完毕后就变成了无用对象，这个时候它的内存就可以被释放。
（2）Java中提供了一些和垃圾收集打交道的类，而且提供了一种强行执行垃圾收集的方法--调用System.gc()，但这同样是个不确定的方法。Java 中并不保证每次调用该方法就一定能够启动垃圾收集，它只不过会向JVM发出这样一个申请，到底是否真正执行垃圾收集，一切都是个未知数。
（3）挑选适合自己的垃圾收集器。一般来说，如果系统没有特殊和苛刻的性能要求，可以采用JVM的缺省选项。否则可以考虑使用有针对性的垃圾收集器，比如增量收集器就比较适合实时性要求较高的系统之中。系统具有较高的配置，有比较多的闲置资源，可以考虑使用并行标记/清除收集器。
（4）关键的也是难把握的问题是内存泄漏。良好的编程习惯和严谨的编程态度永远是最重要的，不要让自己的一个小错误导致内存出现大漏洞。
（5）尽早释放无用对象的引用。大多数程序员在使用临时变量的时候，都是让引用变量在退出活动域(scope)后，自动设置为null，暗示垃圾收集器来收集该对象，还必须注意该引用的对象是否被监听，如果有，则要去掉监听器，然后再赋空值。
就是说,对于频繁申请内存和释放内存的操作,还是自己控制一下比较好,但是System.gc()的方法不一定适用，最好使用finallize强制执行或者写自己的finallize方法。