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:CodingHappyStudyDisposeStudyDisposeStudyProgram.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 是一件挺快乐的事情。