浅谈java是如何做资源回收补救的

  /**
   * Ensures that the <code>close</code> method of this file input stream is
   * called when there are no more references to it.
   *
   * @exception IOException if an I/O error occurs.
   * @see    java.io.FileInputStream#close()
   */
  protected void finalize() throws IOException {
    if ((fd != null) && (fd != FileDescriptor.in)) {
      /* if fd is shared, the references in FileDescriptor
       * will ensure that finalizer is only called when
       * safe to do so. All references using the fd have
       * become unreachable. We can call close()
       */
      close();
    }
  }

   unsafe.setMemory(base, size, (byte) 0);
    if (pa && (base % ps != 0)) {
      // Round up to page boundary
      address = base + ps - (base & (ps - 1));
    } else {
      address = base;
    }
    cleaner = Cleaner.create(this, new Deallocator(base, size, cap));
    att = null;

 private static class Deallocator
    implements Runnable
  {

    private static Unsafe unsafe = Unsafe.getUnsafe();

    private long address;
    private long size;
    private int capacity;

    private Deallocator(long address, long size, int capacity) {
      assert (address != 0);
      this.address = address;
      this.size = size;
      this.capacity = capacity;
    }

    public void run() {
      if (address == 0) {
        // Paranoia
        return;
      }
      unsafe.freeMemory(address);
      address = 0;
      Bits.unreserveMemory(size, capacity);
    }

  }

 private static class ReferenceHandler extends Thread {

    Thread handler = new ReferenceHandler(tg, "Reference Handler");
    /* If there were a special system-only priority greater than
     * MAX_PRIORITY, it would be used here
     */
    handler.setPriority(Thread.MAX_PRIORITY);
    handler.setDaemon(true);
    handler.start();
    SharedSecrets.setJavaLangRefAccess(new JavaLangRefAccess() {
      @Override
      public boolean tryHandlePendingReference() {
        return tryHandlePending(false);
      }
    });

 static boolean tryHandlePending(boolean waitForNotify) {
    Reference<Object> r;
    Cleaner c;
    try {
      synchronized (lock) {
        if (pending != null) {
          r = pending;
          // 'instanceof' might throw OutOfMemoryError sometimes
          // so do this before un-linking 'r' from the 'pending' chain...
          c = r instanceof Cleaner ? (Cleaner) r : null;
          // unlink 'r' from 'pending' chain
          pending = r.discovered;
          r.discovered = null;
        } else {
          // The waiting on the lock may cause an OutOfMemoryError
          // because it may try to allocate exception objects.
          if (waitForNotify) {
            lock.wait();
          }
          // retry if waited
          return waitForNotify;
        }
      }
    } catch (OutOfMemoryError x) {
      // Give other threads CPU time so they hopefully drop some live references
      // and GC reclaims some space.
      // Also prevent CPU intensive spinning in case 'r instanceof Cleaner' above
      // persistently throws OOME for some time...
      Thread.yield();
      // retry
      return true;
    } catch (InterruptedException x) {
      // retry
      return true;
    }

  final JavaLangRefAccess jlra = SharedSecrets.getJavaLangRefAccess();

    // retry while helping enqueue pending Reference objects
    // which includes executing pending Cleaner(s) which includes
    // Cleaner(s) that free direct buffer memory
    while (jlra.tryHandlePendingReference()) {
      if (tryReserveMemory(size, cap)) {
        return;
      }
    }