JAVA 放射、类的加载机制与垃圾回收

13章  放射、类的加载机制与垃圾回收

 

一、类的加载机制和执行机制是虚拟机的两个主要的功能；

1.1、类的加载机制：

         虚拟机把描述类的数据从class文件（字节码文件）加载到内存，并对数据进行校验、转换、解析和初始化，最终形成可以被直接使用的java类型，这既是虚拟机的类加载机制。

要求记忆*

1.2、 类的生命周期

包括加载（loading）、验证（verifcation）、准备（reparation）、解析、初始化、使用、卸载等七个阶段；其中验证、准备、和解析三个部分统称为链接。

        

加载阶段：

         通过一个类的权限定名（包括+类名）来获取定义此类的二进制节流，讲这个字节流所代表的静态储存结构转化为方法区的运行时数据结构，在Java堆中生成一个代表这个类的Java.langClass对象，作物方法区这些数据的访问入口；

验证阶段：

         不同虚拟机会进行不同类验证的实现，。但大致都会完成以下四个阶段的过程：

1）  文件格式校验（检验字节流是否符合class文件格式规范，并能被当前版本的虚拟机处理）

2）  字节码验证（对方法体进行数据流和控制分析，保证类的方法运行时不会做出危害虚拟机的行为）     

3）  符号引用验证（发生在将符号引用转化为直接引用的时候，在解析阶段中发生）。

准备阶段：

         正式为类成员变量分配内存并设置类变量初始值（通常情况下是数据内存的零值，不进行赋值操作）的阶段，这些内存都将在犯法区中进行分配；

解析阶段：

         虚拟机将常量池中的符号引用替换为直接应用的过程。符号引用和内存布局无关，而直接引用的目标必定已经在内存中存在。解析动作主要针对类、字段。类方法。接口方法四类符号引用进行；

初始化机制：

         真正开始执行类中定义的java程序代码（字节码），是执行类构造器的过程。

执行机制：

         Java是通过虚拟机字节码执行引线完成字节码在虚拟机中执行操作。

二、java反射机制

2.1、什么是反射机制：

         是在运行状态中，对已任意一个类都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用他的属性和方法；这种动态获取类的信息以及动态调用对象的方法的功能称为java语言的反射机制。

         简单说：反射机制是指程序在运行时能够获取自身的信息。

         反射是java中一种强大的工具，主要用于开发框架，如JavaBean、structs、hibernate和spring框架都大量是使用反射机制，对于普通java程序员使用比较少，只做了解。

2.2、反射机制的功能：

1）  可以判断运行时的对象所属的类；

2）  可以判断运行时对象所具有的成员变量和方法

3）  通过反射机制甚至可以调用对象的private的方法；

4）  通过反射机制可以实例化类的对象

2.3、实现java反射机制的类

1）  class类：表示在运行的java运行程序中的类和接口

2）  Field类：表示提供有关类或接口的属性信息，以及对他的动态访问权限

3）  Constructor类：表示提供关于类的单个构造器的信息以及对他的访问权限

4）  Mothed类：表示提供关于类或接口中某个方法信息

注意：

class类是java反射机制中最重要的功能类，所有获取对象的信息（方法、属性、构造器和访问权限）都需要他来实现。

 

2.4、反射机制的优点和缺点：

         优点：可以实现动态实例化对象和编译，体现出很大的灵活性。

         缺点：降低性能，增加复杂度。使用反射机制基本上是一种解释操作，我们可以告诉JVM希望做什么并且它满足我们的要求。这类操作总是慢于只直接执行相同的操作。/

2.5、编写JAVA反射程序的步骤：

1）  必须首先获取一个类的Class对象

2）  然后分别调用Class对象中的方法，配合使用Field类、Constructor类、Mothed类来获取一个类的属性、方法和构造器的信息

3）  使用reflection  API来操作这些信息

 

三、GC回收的触发条件

         JVM进行GC回收的频率很高，但因为这种GC占用时间极短，所以对系统产生的影响不大。

         值得关注的是GC的触发条件，因为对系统影响很明显。总体说，有两个条件会触发GC回收；

1）  当应用程序空闲时，GC会被调用

2）  JAVA堆内存不足是，GC会被调用

由于是否进行GC回收由JAVA根据系统环境决定，而系统环境在不断的变化，所以GC的运行具有不确定性，无法预计他何时不然会出现。

 

减少GC开销的措施：

1）  不要显示频率调用system.gc（）。虽然只是建议而已，但很多情况下它会触发GC回收。从而增加GC回收频率，降低程序的运行性能；

2）  尽量减少临时对象（局部对象）的使用。；临时对象或局部对象实在方法中定义，当方法执行完这些对象后将无效，不能再使用，将会被GC回收。

3）  对象不用时最好显示赋值null，这样有利于GC判断垃圾，从而提高GC的回频率。

4）  尽量使用stringBuffer，而不是string来追加字符。

5）  能用基本数据类型int，long,尽量不用对应包装类，也尽量不要频繁装箱和拆箱。

6）  尽量少用静态对象成员变量，这些变量属于全局变量，不会被GC回收，他们会一直占用内存，知道程序退出。

7）  分散对象实例化或销毁的时间，集中在短时间内实例化大量对象，会导致分配大量内存，JVM在面临这种情况时，会频繁进行GC回收内存或整合内存碎片，从而提高GC的频率。

 

System.gc（）：

调用这个方法仅仅是一个请求（或建议）。JVM接受这个请求后，并不是立刻座垃圾回收，而只是对几个垃圾回收算法做了加权，是垃圾回收操作容易发生，或提早发生，或回收较多而已。

Finalize（）方法：

         调用该方法用于处理垃圾回收器不能处理的特殊情况。由于垃圾回收器只知道回收显示地由new实例化对象在内存堆中分配的内存空间，而无法回收采用其他方式（如本地化C/C++调用、打开的文件资源等）分配的特殊内存空间，那么这个时候Java允许在类中定义一个finalize（）方法来负责回收这块特殊的内存空间。

Finalize（）方法调用时机：

         一旦垃圾回收准备释放对象占用的储存空间。首先会去调用Finalize（）方法进行一些必要的清理工作。只有到下一次在进行垃圾回收动作时候，才会真正释放这个对象所占用的内存空。

Finalize（）方法的使用：

         该方法是Object类的方法，使用时需要重写该方法。

Final、finelly、和finalized的区别；

      

final、finally和finalize虽然长得像孪生三兄弟一样，但是它们的含义和用法却是大相径庭。
这一次我们就一起来回顾一下这方面的知识。
final关键字
我们首先来说说final。它可以用于以下四个地方：
1. 定义变量，包括静态的和非静态的。
2. 定义方法的参数。
3. 定义方法。
4. 定义类。
我们依次来回顾一下每种情况下final的作用。首先来看第一种情况，如果final修饰的是一
个基本类型，就表示这个变量被赋予的值是不可变的，即它是个常量；如果final修饰的是
一个对象，就表示这个变量被赋予的引用是不可变的，这里需要提醒大家注意的是，不可改
变的只是这个变量所保存的引用，并不是这个引用所指向的对象。在第二种情况下，final的
含义与第一种情况相同。实际上对于前两种情况，有一种更贴切的表述final的含义的描述，
那就是，如果一个变量或方法参数被final修饰，就表示它只能被赋值一次，但是JAVA虚拟
机为变量设定的默认值不记作一次赋值。
被final修饰的变量必须被初始化。初始化的方式有以下几种：
1. 在定义的时候初始化。
2. final变量可以在初始化块中初始化，不可以在静态初始化块中初始化。
3. 静态final变量可以在静态初始化块中初始化，不可以在初始化块中初始化。
4. final变量还可以在类的构造器中初始化，但是静态final变量不可以。
通过下面的代码可以验证以上的观点：
Java代码
public class FinalTest {
// 在定义时初始化
public final int A = 10;
public final int B;
// 在初始化块中初始化
{
B = 20;
}
// 非静态final变量不能在静态初始化块中初始化
// public final int C;
// static {
// C = 30;
// }
// 静态常量，在定义时初始化
public static final int STATIC_D = 40;
public static final int STATIC_E;
// 静态常量，在静态初始化块中初始化
static {
STATIC_E = 50;
}
// 静态变量不能在初始化块中初始化
// public static final int STATIC_F;
// {
// STATIC_F = 60;
// }
public final int G;
// 静态final变量不可以在构造器中初始化
// public static final int STATIC_H;
// 在构造器中初始化
public FinalTest() {
G = 70;
// 静态final变量不可以在构造器中初始化
// STATIC_H = 80;
// 给final的变量第二次赋值时，编译会报错
// A = 99;
// STATIC_D = 99;
}
// final变量未被初始化，编译时就会报错
// public final int I;
// 静态final变量未被初始化，编译时就会报错
// public static final int STATIC_J;
}
我们运行上面的代码之后出了可以发现final变量（常量）和静态final变量（静态常量）未
被初始化时，编译会报错。
用final修饰的变量（常量）比非final的变量（普通变量）拥有更高的效率，因此我们在实
际编程中应该尽可能多的用常量来代替普通变量，这也是一个很好的编程习惯。
当final用来定义一个方法时，会有什么效果呢？正如大家所知，它表示这个方法不可以被
子类重写，但是它这不影响它被子类继承。我们写段代码来验证一下：
Java代码
class ParentClass {
public final void TestFinal() {
System.out.println("父类--这是一个final方法");
}
}
public class SubClass extends ParentClass {
/**
* 子类无法重写（override）父类的final方法，否则编译时会报错
*/
// public void TestFinal() {
// System.out.println("子类--重写final方法");
// }
public static void main(String[] args) {
SubClass sc = new SubClass();
sc.TestFinal();
}
}
这里需要特殊说明的是，具有private访问权限的方法也可以增加final修饰，但是由于子类
无法继承private方法，因此也无法重写它。编译器在处理private方法时，是按照final方法
来对待的，这样可以提高该方法被调用时的效率。不过子类仍然可以定义同父类中的
private方法具有同样结构的方法，但是这并不会产生重写的效果，而且它们之间也不存在必
然联系。
最后我们再来回顾一下final用于类的情况。这个大家应该也很熟悉了，因为我们最常用的
String类就是final的。由于final类不允许被继承，编译器在处理时把它的所有方法都当作
final的，因此final类比普通类拥有更高的效率。而由关键字abstract定义的抽象类含有必须
由继承自它的子类重载实现的抽象方法，因此无法同时用final和abstract来修饰同一个类。
同样的道理，final也不能用来修饰接口。 final的类的所有方法都不能被重写，但这并不表
示final的类的属性（变量）值也是不可改变的，要想做到final类的属性值不可改变，必须
给它增加final修饰，请看下面的例子：
Java代码
public final class FinalTest {
int i = 10;
public static void main(String[] args) {
FinalTest ft = new FinalTest();
ft.i = 99;
System.out.println(ft.i);
}
}
运行上面的代码试试看，结果是99，而不是初始化时的10。
finally语句
接下来我们一起回顾一下finally的用法。这个就比较简单了，它只能用在try/catch语句中，
并且附带着一个语句块，表示这段语句最终总是被执行。请看下面的代码：
Java代码
public final class FinallyTest {
public static void main(String[] args) {
try {
throw new NullPointerException();
} catch (NullPointerException e) {
System.out.println("程序抛出了异常");
} finally {
System.out.println("执行了finally语句块");
}
}
}
运行结果说明了finally的作用：
1. 程序抛出了异常
2. 执行了finally语句块
请大家注意，捕获程序抛出的异常之后，既不加处理，也不继续向上抛出异常，并不是良好
的编程习惯，它掩盖了程序执行中发生的错误，这里只是方便演示，请不要学习。
那么，有没有一种情况使finally语句块得不到执行呢？大家可能想到了
return、continue、break这三个可以打乱代码顺序执行语句的规律。那我们就来试试看，这
三个语句是否能影响finally语句块的执行：
Java代码
public final class FinallyTest {
// 测试return语句
public ReturnClass testReturn() {
try {
return new ReturnClass();
} catch (Exception e) {
e.printStackTrace();
} finally {
System.out.println("执行了finally语句");
}
return null;
}
// 测试continue语句
public void testContinue() {
for (int i = 0; i < 3; i++) {
try {
System.out.println(i);
if (i == 1) {
continue;
}
} catch (Exception e) {
e.printStackTrace();
} finally {
System.out.println("执行了finally语句");
}
}
}
// 测试break语句
public void testBreak() {
for (int i = 0; i < 3; i++) {
try {
System.out.println(i);
if (i == 1) {
break;
}
} catch (Exception e) {
e.printStackTrace();
} finally {
System.out.println("执行了finally语句");
}
}
}
public static void main(String[] args) {
FinallyTest ft = new FinallyTest();
// 测试return语句
ft.testReturn();
System.out.println();
// 测试continue语句
ft.testContinue();
System.out.println();
// 测试break语句
ft.testBreak();
}
}
class ReturnClass {
public ReturnClass() {
System.out.println("执行了return语句");
}
}
上面这段代码的运行结果如下：
1. 执行了return语句
2. 执行了finally语句
3.
4. 0
5. 执行了finally语句
6. 1
7. 执行了finally语句
8. 2
9. 执行了finally语句
10.
11. 0
12. 执行了finally语句
13. 1
14. 执行了finally语句
很明显，return、continue和break都没能阻止finally语句块的执行。从输出的结果来看，
return语句似乎在 finally语句块之前执行了，事实真的如此吗？我们来想想看，return语句
的作用是什么呢？是退出当前的方法，并将值或对象返回。如果 finally语句块是在return语
句之后执行的，那么return语句被执行后就已经退出当前方法了，finally语句块又如何能被
执行呢？因此，正确的执行顺序应该是这样的：编译器在编译return new ReturnClass();时，
将它分成了两个步骤，new ReturnClass()和return，前一个创建对象的语句是在finally语句块
之前被执行的，而后一个return语句是在finally语句块之后执行的，也就是说finally语句块
是在程序退出方法之前被执行的。同样，finally语句块是在循环被跳过（continue）和中断
（break）之前被执行的。
finalize方法
最后，我们再来看看finalize，它是一个方法，属于java.lang.Object类，它的定义如下：
Java代码
protected void finalize() throws Throwable { }
众所周知，finalize()方法是GC（garbagecollector）运行机制的一部分，关于GC的知识我们
将在后续的章节中来回顾。
在此我们只说说finalize()方法的作用是什么呢？
finalize()方法是在GC清理它所从属的对象时被调用的，如果执行它的过程中抛出了无法捕
获的异常（uncaught exception），GC将终止对改对象的清理，并且该异常会被忽略；直到
下一次GC开始清理这个对象时，它的finalize()会被再次调用。
请看下面的示例：
Java代码
public final class FinallyTest {
// 重写finalize()方法
protected void finalize() throws Throwable {
System.out.println("执行了finalize()方法");
}
public static void main(String[] args) {
FinallyTest ft = new FinallyTest();
ft = null;
System.gc();
}
}
运行结果如下：
• 执行了finalize()方法
程序调用了java.lang.System类的gc()方法，引起GC的执行，GC在清理ft对象时调用了它
的finalize()方法，因此才有了上面的输出结果。调用System.gc()等同于调用下面这行代码：
Java代码
Runtime.getRuntime().gc();
调用它们的作用只是建议垃圾收集器（GC）启动，清理无用的对象释放内存空间，但是GC
的启动并不是一定的，这由JAVA虚拟机来决定。直到 JAVA虚拟机停止运行，有些对象的
finalize()可能都没有被运行过，那么怎样保证所有对象的这个方法在JAVA虚拟机停止运行
之前一定被调用呢？答案是我们可以调用System类的另一个方法：
Java代码
public static void runFinalizersOnExit(boolean value) {
//other code
}
给这个方法传入true就可以保证对象的finalize()方法在JAVA虚拟机停止运行前一定被运行
了，不过遗憾的是这个方法是不安全的，它会导致有用的对象finalize()被误调用，因此已经
不被赞成使用了。
由于finalize()属于Object类，因此所有类都有这个方法，Object的任意子类都可以重写
（override）该方法，在其中释放系统资源或者做其它的清理工作，如关闭输入输出流。