The vast majority of resources used in Java programs are objects, and garbage collection does a fine job of cleaning them up. Go ahead, use as many Strings as you want. The garbage collector eventually figures out when they've outlived their usefulness, with no help from you, and reclaims the memory they used.

On the other hand, nonmemory resources like file handles and socket handles must be explicitly released by the program, using methods with names like close(), destroy(), shutdown(), or release().

Most resources are not held for the lifetime of the application; instead, they are acquired for the lifetime of an activity.

We all know that we should use finally to release heavyweight objects like database connections, but we're not always so careful about using it to close streams[...]. It's also easy to forget to use finally when the code that uses the resource doesn't throw checked exceptions.

Statement statement = null;
ResultSet resultSet = null;
Connection connection = getConnection();
   try {
      statement = connection.createStatement();
      resultSet = statement.executeQuery("SELECT * FROM Bar");
     // Use resultSet
   }
   finally {
     try {
        if (resultSet != null)
             resultSet.close();
        }
     finally {
        try {
            if (statement != null)
                statement.close();
            }
        finally {
            connection.close();
        }
     }
 }

We're back to where we were with C -- managing resource lifecycles manually. In a server application where clients make a persistent network connection to the server for the duration of a session (like a multiplayer game server), any resources acquired on a per-user basis (including the socket connection) must be released when the user logs out.

[...] Resources with arbitrary lifecycles are almost certainly going to be stored in [...] a global collection somewhere. To avoid resource leaks, it is therefore critical to identify when the resource is no longer needed and remove it from this global collection.

A key technique for ensuring timely resource release is to maintain a strict hierarchy of ownership; with ownership comes the responsibility to release the resource. If an application creates a thread pool and the thread pool creates threads, the threads are resources that must be released (allowed to terminate) before the program can exit.

But the application doesn't own the threads; the thread pool does, and therefore the thread pool must take responsibility for releasing them. Of course, it can't release them until the thread pool itself is released by the application.

Connection connection = getConnection();
try {
 Statement statement = connection.createStatement();
 try {
  ResultSet rs = statement.executeQuery("...");
  try {
   // ... use rs
  } finally {
   rs.close();
  }
 } finally {
  statement.close();
 }
} finally {
 connection.close();
}

final AClass resource =  allocateResource();
try {
    // ...
    // resource usage
    // ...
}
finally {
    resource.release();
}

> final AClass resource =  allocateResource();
> try {
>     // ...
>     // resource usage
>     // ...
> }
> finally {
>     resource.release();
> }
> 

Session session = SessionMaker.currentSession();
Transaction txn = null;
try {
    txn = session.beginTransaction();
 
    // Do stuff
 
    txn.commit();
}
catch (Exception e) {
    try {
        if (txn != null) {
            txn.rollback();
        }
    }
    catch (HibernateException e1) {
        // Deal with inability to roll back
    }
    finally {
       throw e; 
    }
}
finally {
    SessionMaker.closeSession();
}

> final AClass resource =  allocateResource();
> try {
>     // ...
>     // resource usage
>     // ...
> }
> finally {
>     resource.release();
> }
> 

Statement statement = null;
ResultSet resultSet = null;
Connection connection = getConnection();
try {
  statement = connection.createStatement();
  resultSet = statement.executeQuery("SELECT * FROM Bar");
   // Use resultSet
}
finally {
  close (connection, statement, resultSet);
}

void close (Connection connection, Statement statement, ResultSet resultSet) {
  try {
    if (resultSet != null)
      resultSet.close();
  }
  finally {
    try {
      if (statement != null)
        statement.close();
      }
    finally {
      if (connection != null)  
        connection.close();
    }
  }
}

>    public static void close(OutputStream stream) {
>       if (stream != null) {
>          try {
>             stream.close();
>          }
>          catch (IOException e) {
>             // ignore         
>          }
>       }
>    }