Java：终结器防卫者，顺便看一下 C# 如何做的。

背景

多数情况我们不需要重写 finalize 方法，只有当我们需要持有未托管资源的时候才需要，而此时重写 finalize 方法，只是作为一个“安全网”，不能作为常规的资源释放模式，必须提供显式的释放方法，如：close。

如果某个类型重写了 finalize 方法，但是这个类型是可以继承的，这就要求所有的子类如果也重写了 finalize，就必须要调用父类的 finalize 方法，我们有三种策略：

1. 按照约定。
2. 终结器防卫者。
3. 模板方法模式。

本文就介绍第 2 种模式，此模式是昨天看《Effective Java 第二版》时学习的，本文后面会介绍 C# 是如何做的。

Java版：终结器防卫者

测试代码

注意看注释，我就不多说了。

 public class Program {

     public static void main(String[] args) throws InterruptedException {
         {
             new CustomResourceOwner().doSomeThing();
         }

         System.gc();

         System.out.println("程序结束！");
     }
 }

  class ResourceOwnerBase {
     // 可以将父类中 finalize 的代码放到守卫者里，一定会被调用的。
     @SuppressWarnings("unused")
     private final Object finalizeGuarder = new Object() {
         @Override
         public void finalize() {
             System.out.println("在资源守卫者中销毁父类！");
         }
     };

     // 子类可能故意不调用父类！
     @Override
     public void finalize() {
         System.out.println("销毁父类！");
     }
 }

  final class CustomResourceOwner extends ResourceOwnerBase {
     @Override
     public void finalize() {
         System.out.println("销毁子类！");

         // 故意不调用父类！
         // super.finalize();
     }

     public void doSomeThing() {
         System.out.println("随便做点工作！");
     }
 }

输出结果

 随便做点工作！
 程序结束！
 在资源守卫者中销毁父类！
 销毁子类！

说明

因为终结器防卫者只被资源拥有者持有，当资源拥有者变为垃圾的时候，终结器防卫者也会变为垃圾。

C#版：“终结器防卫者”

测试代码

 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 using System.IO;

 namespace DisposeStudy
 {
     class Program
     {
         static void Main()
         {
             {
                 var res = new CustomResourceOwner(IntPtr.Zero);
                 res.DoSomeThing();
             }
         }
     }

     class ResourceOwnerBase : IDisposable
     {
         private bool _disposed;
         private readonly FileStream _fileStream;
         private IntPtr _handle;

         protected ResourceOwnerBase(IntPtr handle)
         {
             _handle = handle;
             _fileStream = File.OpenRead(@"E:\Coding\HappyStudy\DisposeStudy\DisposeStudy\Program.cs");
         }

         protected bool Disposed
         {
             get { return _disposed; }
         }

         public void Dispose()
         {
             Dispose(true);

             GC.SuppressFinalize(this);
         }

         protected virtual void Dispose(bool disposing)
         {
             if (Disposed)
             {
                 if (disposing)
                 {
                     _fileStream.Dispose();
                 }

                 CloseHandle(_handle);
                 _handle = IntPtr.Zero;

                 _disposed = true;
             }
         }

         ~ResourceOwnerBase()
         {
             Console.WriteLine("父类析构方法！");
             Dispose(false);
         }

         [System.Runtime.InteropServices.DllImport("Kernel32")]
         private extern static Boolean CloseHandle(IntPtr handle);
     }

     sealed class CustomResourceOwner : ResourceOwnerBase
     {
         public CustomResourceOwner(IntPtr handle)
             : base(handle)
         {
         }

         public void DoSomeThing()
         {
             if (Disposed)
             {
                 throw new ObjectDisposedException("资源已经消耗了，不能执行此操作！");
             }

             Console.WriteLine("随便做点工作！");
         }

         ~CustomResourceOwner()
         {
             Console.WriteLine("子类析构方法！");
         }
     }
 }

输出结果

说明

让我们看看编译器帮我们做了什么工作：

看完大家就明白了，C#在编译器层面保证了子类的终结器一定会调用父类的终结器。

备注

同时学习 C# 和 Java 是一件挺快乐的事情。