Java复习（二）：初始化与清理

• 初始化与清理
  随着计算机革命的发展，“不安全”的编程方式以及逐步成为编程代价高昂的主因之一。初始化和清理（cleanup）正是涉及安全的两个问题。

  用构造器确保初始化：
  在Java中，通过提供构造器，类的设计者可确保每个对象都会得到初始化。创建对象时，如果其类具有构造器，Java就会在用户有能力操作对象之前自动调用相应的构造器，从而保证了初始化的进行。如何命名这个构造方法？有两个问题：第一。所取的任何名字都可能与类的某个成员名称相冲突；第二，调用构造器是编译器的责任，所以必须让编译器知道应该调用哪个方法进行初始化。C++中采用的解决方案看起来最简单而且更符合逻辑，所以在Java中也采用了这种方案：即构造器采用与类相同的名称。以下就是带有构造器的简单类：

  /**
   * @author Tom-Chen
   * Time : 2022-01-11 13:10
   */
  
  class Rock{
      Rock(){ //This is the constructor
          System.out.print("Rock ");
      }
  }
  
  
  public class SimpleConstructor {
      public static void main(String[] args) {
          for (int i = 0 ; i < 10; i++){
              new Rock();
          }
      }
  }
  
  //output
  Rock Rock Rock Rock Rock Rock Rock Rock Rock Rock 
  

  现在，在创建对象 new Rock();将会为对象分配存储空间，并调用相应的构造器。这就确保了在你操作对象之前，它已经被恰当的初始化了。需要注意的是，由于构造器的名称必须与类名完全相同，所以“每个方法首字母小写”的编码风格并不适用于构造器。不接受任何参数的构造器被称为默认构造器，也被称为无参构造器。当然，和其它方法一样，构造器也能带有形式参数，以便指定如何创建对象。将上述例子进行修改：

  /**
   * @author Tom-Chen
   * Time : 2022-01-11 13:10
   */
  
  class Rock{
      Rock(int i){ //This is the constructor
          System.out.print("Rock:" + i + " ");
      }
  }
  
  
  public class SimpleConstructor {
      public static void main(String[] args) {
          for (int i = 0 ; i < 10; i++){
              new Rock(i);
          }
      }
  }
  
  //output:
  Rock:0 Rock:1 Rock:2 Rock:3 Rock:4 Rock:5 Rock:6 Rock:7 Rock:8 Rock:9 
  

  如果Rock中带形参的构造器是唯一的构造器，那么编译器将不会允许你使用其它任何方式创建Rock对象。
  构造器有助于减少错误，并使代码更易于阅读。从概念上讲，“初始化”与“创建”是彼此独立的，然而在上面的代码中，你却找不到initialize()方法的明确调用。在Java中，“初始化”和“创建”捆绑在一起，两者不能分离。
  构造器是一种特殊类型的方法，因为它没有返回值。这和 返回值为空的(void) 方法有着明显的差别。对于空返回值，尽管方法本身不会自动返回什么，但仍可选择让它返回其它东西。构造器则不会返回任何东西，你别无选择（new 表达式确实返回了对新建对象的引用，但构造器本身并没有返回任何值）。假如构造器具有返回值，并且允许人们自行悬着返回类型，那么势必得让编译器知道如何处理此返回值。
  方法重载：
  任何程序设计语言都具备的一项重要特性就是对名字的运用。当创建一个对象时，也就给此对象分配到的存储空间取了一个名字。所谓方法就是给某个动作取了一个名字。通过使用名字，你可以引用所有的对象和方法。名字起得好可以使系统更加容易理解和修改。Java如何区分你指的是哪一个方法呢？其实很简单，每一个重载的方法都必须有独一无二的参数类型列表。同名同返回值不同参，方法被调用时会根据参数类型进行选择，如果是同参不同返回值的话会根据返回参数类型进行选择。
  默认构造器：
  默认构造器是没有形式参数的——他的作用是创建一个默认对象。如果你写的类中没有构造器，则编译器就会自动帮你创建一个默认构造器。
  this关键字：
  假设你希望在方法的内部获得对当前对象的引用。由于这个引用是编译器“偷偷”传入的，所以没有标识符可用。但是，为此有一个专门的关键字：this。this关键字只能在方法内部使用，表示对“调用方法的那个对象”的引用。this的用法和其它对象的引用并无不同。但要注意的是，如果在方法内部调用同一个类的另一个方法，就不必使用this，直接调用即可。当然，当全局变量和形式参数参数名相同时，this还具有区分形参和全局变量(this.参数名代表全局变量)的功能。
  在构造器中调用构造器：
  可能一个类中写多个构造器，有时可能想在一个构造器中调用另一个构造器，以避免重复的代码。可以用“this”关键字来做到这一点。
  通常写this都是代表当前类的引用，在构造器中如果为this添加了参数列表，那么就有了不同的含义。这将产生对符合此参数列表的某个构造器的明确调用。
  static的含义：
  了解了this关键字后，我们就能更全面的理解static（静态）方法的含义。static就时没有this的方法。在static方法的内部不能调用非静态方法，反过来是可以的。而且可以在没有创建任何对象的前提下，仅仅通过类本身来调用static方法。这实际上正是static方法的主要用途。它很像全局方法。Java中禁止使用全局方法，但你在类中置入static方法就可以访问其它static方法和static域。
  有些人认为static方法不是“面对对象”的思想的，因为它们的确具有全局函数的语义；
  使用static方法时，由于不存在this关键字，所以不是通过“向对象发送消息”的方式来完成的。的确，要是在代码中出现过多的static方法，就需要考虑这个程序的设计了。然而，static的概念其实还是有很多实用之处的，许多时候都要用到它。
  终结处理和垃圾回收：
  程序员都了解初始化的重要性，但是常常忽略同样重要的清理工作。虽然Java自带了垃圾回收机制，但是也会有一些特殊的内存区域无法被垃圾回收器回收。假定你的对象(并非使用new)获得了一块特殊的内存区域，由于垃圾回收器只知道释放那些经由new分配的内存空间，所以它不知道怎么释放该对象这块“特殊”内存。为了应对这个问题，Java允许在类中定义 finalize()方法。这里有一个潜在的编程陷阱，因为有些程序员刚开始可能会误把finalize()当做C++当中的析构函数（C++中销毁对象必须要用到这个函数）。所以有必要做一个明确的区分：在C++中，对象一定会被销毁（如果程序没有缺陷的话）；而Java里的对象却并非总是被垃圾回收，或者换句话说：1.对象可能不被回收器回收；2.垃圾回收并不等于“析构”。 Java并为提供“析构函数”或相似的概念，要做类似的清理工作需要自己动手创建一个执行清理工作的普通方法。例如，假设某个对象创建过程中会将自己绘制在屏幕上，如果不是明确的从屏幕上将其擦除，它可能永远都得不到清理。如果在finalize()里加入某种擦除功能，当“垃圾回收”发生时（不能保证一定会发生），finalize()得到了调用，图像就会被擦除。要是“垃圾回收”没有发生，图像就会被一直保留下来。也许你会发现，只要程序没有濒临存储空间耗尽的那一刻，对象占用的空间就总也得不到释放。如果程序执行结束，并且垃圾回收器一直没有释放你创建的任何对象的存储空间，则随着程序的退出，那些资源也会全部交还给操作系统。这个策略时恰当的，因为垃圾回收本身也有开销，要是不使用它，那就不用支付这部分开销了。现在已经明白不该将finalize()最为通用的清理方法。那么，finalize()真正的用途是什么呢？ 3.垃圾回收只与内存有关。 也就是说，使用垃圾回收器唯一的原因就是为了回收程序不再使用的内存。所以对于垃圾回收有关的任何行为来说（尤其时finalize()方法），它们也必须同内存及其回收有关。那如果对象中含有另一个对象时，finalize()需要明确释放另一个对象吗？答案是：不，无论对象是如何创建的，垃圾回收器都会负责释放对象占据的所有内存。这就将对finalize()的需求限制到了一种特殊情况，即通过通过某种创建对象方式之外的方式为对象分配了存储空间。但是，Java不是万物皆对象吗？那到底是一种什么特殊的创建方式呢？其实这种方式发生在“本地方法”调用时，本地方法是一种Java代码调用非Java代码的方式。虽然Java目前本地方法只支持C和C++，但是C和C++可以调用其它语言写的代码，所以实际上是可以调用任何代码的。在非Java代码中，可能会调用C的malloc()函数系列来分配存储空间，而且除非调用了 free()函数，否则存储空间将得不到释放，从而造成内存泄漏。当然，free()是C和C++中的函数，所以需要在finalize()方法中用本地方法调用它。
  要清理一个对象，用户必须在需要清理的时候刻意的调用执行清理动作的方法。这与C++中的析构函数的概念稍有抵触。在C++中，所有的对象都会被销毁，或者说，应该被销毁。如果在C++中创建了一个局部对象（也就是在堆栈上创建，这个在Java中行不通），此时的销毁动作发生在‘}’为边界的对象作用域中。如果对象是用new的方式创建的（类似于Java），那么程序员如果忘记调用delete，那么永远不会调用析构函数，这样的话就会造成内存泄漏，对象的其它部分也不会得到清理，这种缺陷很难追踪。相反，Java不允许创建局部对象，必须使用new创建对象。在Java中，也没有用于释放的delete，因为垃圾回收器会帮助你释放存储空间。甚至可以肤浅的认为，正是因为有了垃圾回收器，所以Java没有析构函数。然而，随着学习的深入，慢慢就会明白垃圾回收器的存在并不能完全替代析构函数。（而且绝对不能直接调用finalize()，所以这也不是一种解决方案。）如果希望进行除释放存储空间之外的清理工作，还得明确调用某个恰当的Java方法。这就等同于使用析构函数了，只是没有那么方便。需要注意的是，无论是“垃圾回收”还是“终结”，都不保证一定会发生。如果是Java虚拟机并未面临内存耗尽的情形，它是不会浪费时间去执行垃圾回收以恢复内存的。
  通常，不能指望finalize()，必须创建其它的“清理”方法，并且明确的调用它们。虽然finalize()方法好像只有在晦涩的用法里出现，不过finalize()还有一个有趣的用法。它并不依赖于每次都要对finalize()进行调用。当对某个对象不再感兴趣的时候，也就它需要被清理了，这个对象应该处于某种状态，使它占用的内存可以被安全的释放。例如，要是对象代表了一个打开的文件，对象被回收前程序员应该关闭这个文件。只要对象中存在没有被适当清理的部分，程序就存在很隐晦的缺陷。finalize()可以用来最终发现这种问题，尽管它并不会总是被调用。如果某次finalize()的动作使得缺陷被发现，那么就可以据此找到问题所在。以下是一个简单的例子，示范了finalize()可能的使用方式：

  	/**
   * @author Tom-Chen
   * Time : 2022-01-11 16:51
   */
  
  class Book{
      boolean checkedOut = false;
      Book(boolean checkOut){
          checkedOut = checkOut;
      }
  
      void checkIn(){
          checkedOut = false;
      }
  
      protected void finalize() throws Throwable {
          if (checkedOut){
              System.out.println("Error : checked out");
              super.finalize();
          }
      }
  }
  
  public class TerminationCondition {
      public static void main(String[] args) {
          Book novel = new Book(true);
          novel.checkIn();
          new Book(true);
          System.gc();
      }
  }
  
  
  //output
  Error : checked out
  

  本例的终结条件是，所有的Book对象在被当作垃圾回收前都应该被签入(check in）。但在main方法中，由于程序员的错误，有一本书没有被签入。要是没有finalize()来验证终结条件，将很难发现这种缺陷。我们看到代码中System.gc();用于强制进行终结动作，就算不这么做，通过重复的执行程序（当你程序分配大量的存储空间而导致垃圾回收动作的执行），最终也能找到错误的Book对象。你应该总是假设基类的finalize()也要做某些重要的事情，因此你要调用它，就像在Book.finalize()方法中看到的那样。
  垃圾回收器如何工作：
  垃圾回收器对于提高对象的创建速度，具有明显的效果。听起来好像无法将它们联系起来——存储空间的释放竟然会影响到存储空间的分配，但这确实是某些Java虚拟机的工作方式。这也意味着，Java从堆分配空间的速度，可以和其它语言从堆栈上分配空间的速度相媲美。打个比方，你可以把C++里的堆想象成一个院子，里面每个对象都负责管理自己的地盘。一段时间后，对象可能被销毁，但是地盘需要被复用。在某些Java虚拟机中，堆的实现截然不同：它更像传送带，每分配一个新对象，它就往前移动一格。这就意味着对象的分配速度很快。Java的“堆指针”知识简单的移动到尚未分配的区域，其效率比得上C++堆栈上的分配空间的效率。当然，实际过程中在簿记工作方面还有少量的额外开销，但比不上查找可用空间开销大。
  Java中的堆未必完全像传送带那样工作，要真是那样的话会导致频繁的内存页面调度——将其移进移出硬盘，因此会显得需要拥有比实际需要更多的内存。页面调度会显著的影响性能，最终，在创建了足够多的对象之后，内存资源将会耗尽。其中的秘密在于垃圾回收器的介入。当它工作时，会一边回收空间一边使堆中的对象紧凑排列，这样“堆指针”就可以很容易的移动到更靠近传送带的开始处，也就尽量避免了页面错误。通过垃圾回收器对对象的重新排列，实现了一种高速的、有无限空间可供分配的对模型。
  想更好的理解Java中的垃圾回收机制的话，先了解其它系统中的垃圾回收机制将会很有帮助。引用计数是一种简单但速度很慢的垃圾回收技术。每个对象都含有一个引用计数器，当有引用连接至对象时，引用计数加1.当引用离开作用域或被置为null时，引用计数减1.虽然管理引用计数的开销不大，但这项开销在整个程序生命周期中将持续发生。垃圾回收器会在含有全部对象的列表上遍历，当发现某个对象的引用计数为0时，就释放其占用的空间（但是，引用计数模式经常会在计数值变为0时立即释放对象）。这种方法有个缺陷，如果对象之间存在循环引用，可能会出现“对象应该被回收，但引用计数却不为0”的情况。对于垃圾回收器而言，定位这样的交互自引用的对象组所需要的工作量极大。引用计数常用来说明垃圾收集的工作方式，但似乎没有被任何一种Java虚拟机应用。
  在更快的模式中，垃圾回收器并非基于引用计数技术。它们依据的思想是：对任何还“活”着的对象，一定能最终追溯到其存活在堆栈或静态存储区之中的引用。这条引用链可能会穿过数个对象层次。由此，如果从堆栈和静态区开始，遍历所有的引用，就能找到所有活着的对象。对于发现的每个引用，必须追踪它所引用的对象，然后是此对象包含的全部引用，如此反复进行，直到“根源于堆栈或静态存储区的引用”所形成的网络全部被访问为止。你所访问过的对象必须是活的。注意，这就解决了“交互自引用的对象组”的问题——这种现象根本不会被发现，因此也就被自动回收了。
  在这种方式下，Java虚拟机将采用一种自适应的垃圾回收技术。至于如何处理找到的存活对象，这就取决于不同的Java虚拟机实现。有一种做法是 停止-复制 (stop-and-copy）。显然这意味着，先要暂停程序的运行（所以它不属于后台回收模式），然后将存活的对象从当前堆复制到另一个堆，没有被复制的全都是垃圾。当对象复制到新堆时，他们是一个挨着一个，多以新堆保持紧凑排列，然后就可以按照前述方法简单、直接的分配新空间了。
  当把对象从一处搬到另一处的时候，所有指向它的那些引用都需要进行修正。位于堆或静态存储区的引用可以直接被修正，但可能还有一些指向这些对象的引用，它们在遍历的过程中才能被找到（可以想象成有个表格，将旧地址映射到新地址）。
  对于这种所谓的“复制回收器”而言，效率会降低，这又两个原因。首先，得有两个堆，然后得在这两个堆之间来回倒腾，从而得维护比实际多一倍得空间。在某些Java虚拟机对此问题得处理方式是，按需从堆中分配几块较大的内存，复制动作发生在这几块较大的内存之间。第二个问题在于复制。程序进入稳定状态时，可能只会产生少量的垃圾，甚至可能没有垃圾。尽管如此，复制式回收器任然会将所有的内存自一处复制到另一处，这很浪费。为了避免这种情形，一些Java虚拟机会进行检查：要是没有新垃圾产生，就会切换到另一种工作模式（这就是“自适应”）。这种模式称为“标记-清扫(mark-and-sweep)”，sun公司早期版本的Java虚拟机使用了这个技术。对于一般用途而言，标记清扫的效率相当低，但是当你知道只会产生少量的垃圾甚至不会产生垃圾时，它的速度就很快了。
  “标记-清扫”所依据的思想同样是从堆栈和静态区出发，遍历所有的引用，从而找出所有存活的对象。每当它找到一个存活的对象时，就会给这个对象设一个标记，这个过程中不会回收任何对象。只有等标记工作全部做完的时候，清理动作才会开始。在清理过程中没有标记的对象将会被释放，不会发生任何复制动作。所以剩下的堆空间是不连续的，垃圾回收器要是希望得到连续空间的话，就需要重新整理剩下的对象。
  “停止-复制”的意思是这种垃圾回收动作不是在后台运行的；而且刚好相反，垃圾动作回收时需要将程序暂停。在sun公司的文档中将垃圾回收视为低优先级的后台进程，但事实上垃圾回收器在sun公司早期版本的Java虚拟机中并未以这种方式实现。当可用内存数量较低时，sun版本的垃圾回收器会暂停运行程序，同样，“标记-清扫”工作也必须在程序暂停的情况下才能进行。
  如同之前说的，在这里所讨论的虚拟机中，内存分配以较大的“块”为单位。如果对象较大他就会占用单独的块。严格来说，“停止-复制”要求在释放旧有对象之前，必须先把所有存活的对象从旧堆复制到新堆，这就导致大量内存复制行为。有了块之后，垃圾回收器在回收的时候就可以往废弃的块中拷贝对象了。每个块都有相应的代数（generation count）来记录它是否还存活。通常，如果块在某处被引用了，其代数就会增加。垃圾回收器将对上次回收动作之后新分配的块进行整理。这对大量短命的临时对象很有帮助。垃圾回收器会定期进行完整的清理动作——大型对象任然不会被复制（只是其代数会增加），内含小型对象的那些块则被复制并整理。Java虚拟机会进行监视，如果所有的对象都很稳定，垃圾回收器的效率降低的话，就切换到“标记-清扫”的模式；同样，Java虚拟机会跟踪“标记-清扫”的效果，如果堆空间出现很多碎片，就会切换回“停止-复制”模式。这就是“自适应”技术。Java虚拟机中有许多附加的技术用以提升速度。尤其是与加载器有关系的，被称为“即时”（Just-In-Time,JIT）编译器技术。这种技术可以把程序全部或部分翻译成本地机器码（这本来就是Java虚拟机的工作），程序的速度因此得以提升。当需要装载某个类（通常是在为该类创建第一个对象）的时候，编译器会先找到其.class文件，然后将该类字节码装入内存。此时有两种方案可以选择。一种就是让即时编译器编译所有代码。但这样做有两个缺陷：这种加载动作散落在整个程序周期内，累加起来要花更多时间；并且会增加可执行代码的长度（字节码要比即时编译器展开后的本地机器码小很多），这将导致页面调度，从而降低程序速度。另一种做法称为惰性评估（lazy evaluation），意思是即时编译器只在必要的时候才编译代码。这样，从不会被执行的代码也许压根就不会被JIT所编译。新版的JDK中的Java HosSpot技术就采用了类似方法，代码每次被执行的时候都会做一些优化，所以执行的次数越多，它的速度就越快。
  关于初始化与清理的总结：
  构造器，这种精巧的初始化机制，给出了强大的暗示：初始化在Java中占有至关重要的地位。C++的发明人Bjarne Stroustrup 在设计C++期间，在针对C语言生产效率所进行的最初调查发现，大量编程错误都源自不正确的初始化。这种错误很难发现，并且不恰当的清理也会导致类似问题。构造器能保证正确的初始化和清理（没有正确的构造器调用，编译器就不允许创建对象），所以有了完全的控制，也很安全。
  在C++中，“析构”相当重要，因为用new创建的对象必须明确被销毁。在Java中，垃圾回收器会自动为对象释放内存，所以在很多场合中，类似清理方法在Java中就不太需要了（不过在有需要的时候，也可以自己动手）。在不需要类似析构函数的行为的时候，Java的垃圾回收器可以极大的简化编程工作，而且在处理内存的时候也更安全。有些垃圾回收器甚至可以清理其他资源，比如图形和文件句柄。然而，垃圾回收器确实也增加了运行时的开销。而且Java解释器从来就很慢，所以这种开销到底造成了多大的影响也很难看出。随着时间的推移，Java在性能方面已经取得了长足的进步，但速度问题仍然是它涉足某些特定编程领域的障碍。

文章参考：Thinking in Java 第四版