如何优化嵌套try-finally的Future.fromTry写法？避免资源泄漏

Great question! That nested Try and try-finally combo does feel unnecessarily verbose, but we can definitely simplify it while still guaranteeing no resource leaks. Let's break down a couple of better approaches:

Approach 1: Simplify with Future.apply #

The Future.apply method already wraps its computation in a Try under the hood—if the code inside throws an exception, the Future will be in a failed state. This lets us drop the outer Try entirely, keeping only the essential try-finally to ensure the stream gets closed:

import scala.concurrent.Future

def close(ous: OutputStream): Future[Unit] = {
  Future {
    try {
      ous.flush()
    } finally {
      ous.close()
    }
  }
}

This does exactly what your original code does, but without the redundant nested error handling. The finally block guarantees close() runs whether flush() succeeds or throws an exception, so no resource leaks here.

Approach 2: Use Scala's Built-in Resource Management (Scala 2.13+) #

If you're using Scala 2.13 or later, the Using utility class handles resource cleanup automatically (it uses try-finally under the hood), which lets us eliminate manual try-finally entirely:

import scala.util.Using
import scala.concurrent.Future

def close(ous: OutputStream): Future[Unit] = {
  Future {
    Using(ous) { stream =>
      stream.flush()
    }
  }.flatMap(Future.fromTry)
}

Here, Using takes care of calling close() on the OutputStream (since it implements AutoCloseable) once the block completes—success or failure. We wrap the Using call in a Future to get the asynchronous behavior, then convert the resulting Try[Unit] to a Future with flatMap and Future.fromTry.

This is the most idiomatic and concise option if you're on a recent Scala version.

Both approaches maintain the critical resource safety you need while cleaning up the code significantly.

内容的提问来源于stack exchange，提问作者Some Name