Java techniques for end-of-lifetime of objects

Question

Experienced programmer new to Java seeking your wisdom:

If there is no way to ensure that some particular chunk code is executed as an object goes out of scope, then what other approaches are there that would offer the same functionality? (it seems finalize is clearly not meant for that)

A classic example is the scoped lock idiom:

void method()
{
    // Thread-unsafe operations {...}

    { // <- New scope
        // Give a mutex to the lock
        ScopedLock lock(m_mutex);

        // thread safe operations {...}

        if (...) return; // Mutex is unlocked automatically on return

        // thread safe operations {...}

    } // <- End of scope, Mutex is unlocked automatically

    // Thread-unsafe operations {...}
}

I can understand that in Java it would be frowned upon to have some code executed if you haven't explicitly called it. But I find being able to enforce some code to be executed at the end of an object's lifetime is a very powerful feature to ensure your classes are being used sensibly by client code. Thanks

Answer 1

Generally - if you have a need to actually close/dispose of resources then using a try{} finally{} structure is encouraged.

  // The old way - using try/finally
  Statement stmt = con.createStatement();
  try {
    ResultSet rs = stmt.executeQuery(query);
    while (rs.next()) {
      // ...
    }
  } catch (SQLException e) {
    // Whatever ... .
  } finally {
    // Be sure to close the statement.
    if (stmt != null) {
      stmt.close();
    }
  }

More recent incarnations of java have the AutoCloseable interface which you can use with the with mechanism. All Closeable objects are automatically AutoCloseable.

  // Example of what is called try-with
  try (Statement stmt = con.createStatement()) {
    ResultSet rs = stmt.executeQuery(query);
    while (rs.next()) {
      // ...
    }
  } catch (SQLException e) {
    // Whatever ... stmt will be closed.
  }

Answer 2

As of Java 7 there is the Automatic Resource Management. If your lock is under your control, then make it implement AutoCloseable. Unfortunately, the java.util.concurrent locks do not implement this interface. Here's a good reference to the details of that.