Try-with-resources and Using Patterns

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

// DON'T DO THIS: Using finalize() for resource cleanup
public class DatabaseConnection {
    private Connection connection;
    
    public DatabaseConnection(String url) throws SQLException {
        connection = DriverManager.getConnection(url);
    }
    
    // DANGEROUS: finalize() is NOT reliable for cleanup
    @Override
    protected void finalize() throws Throwable {
        try {
            if (connection != null && !connection.isClosed()) {
                connection.close();  
                // This might run hours later, or never!
            }
        } finally {
            super.finalize();
        }
    }
}
 
// What happens in practice:
void problematicUsage() throws SQLException {
    for (int i = 0; i < 10000; i++) {
        DatabaseConnection db = new DatabaseConnection(url);
        db.query("SELECT 1");
        // Lost reference - but connection not closed!
        // GC might not run for a long time
        // Database connection pool exhausted after ~100 iterations
    }
    // System.gc() doesn't guarantee finalization either!
}
 
// Real-world consequence:
// "Too many connections" error after running for a few minutes
// Production incident at 2 AM when traffic spike exhausts connection pool

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

import java.io.*;
import java.sql.*;
 
// Basic try-with-resources usage
public void readFile(String path) throws IOException {
    // Resource declared in try() - automatically closed
    try (BufferedReader reader = new BufferedReader(new FileReader(path))) {
        String line;
        while ((line = reader.readLine()) != null) {
            processLine(line);
        }
    }  // reader.close() called here - GUARANTEED
}
 
// Multiple resources - closed in reverse order of declaration
public void copyFile(String source, String dest) throws IOException {
    try (
        FileInputStream in = new FileInputStream(source);
        FileOutputStream out = new FileOutputStream(dest)
    ) {
        byte[] buffer = new byte[8192];
        int bytesRead;
        while ((bytesRead = in.read(buffer)) != -1) {
            out.write(buffer, 0, bytesRead);
        }
    }  // out.close() called first, then in.close()
}
 
// Database transaction with automatic rollback
public void transferFunds(String fromId, String toId, BigDecimal amount) 
        throws SQLException {
    try (
        Connection conn = dataSource.getConnection();
        PreparedStatement debit = conn.prepareStatement(
            "UPDATE accounts SET balance = balance - ? WHERE id = ?");
        PreparedStatement credit = conn.prepareStatement(
            "UPDATE accounts SET balance = balance + ? WHERE id = ?")
    ) {
        conn.setAutoCommit(false);
        
        debit.setBigDecimal(1, amount);
        debit.setString(2, fromId);
        debit.executeUpdate();
        
        credit.setBigDecimal(1, amount);
        credit.setString(2, toId);
        credit.executeUpdate();
        
        conn.commit();
        
    }  // All three closed automatically
    // If exception thrown before commit, connection closed without commit
    // Most JDBC drivers rollback uncommitted transactions on close
}
 
// Java 9+ enhancement: effectively final variables can be used
public void java9Enhancement(Connection preexistingConnection) 
        throws SQLException {
    // conn is effectively final (assigned once, never modified)
    Connection conn = preexistingConnection;
    
    // Java 9+ allows using it directly in try-with-resources
    try (conn) {  
        // Use connection
    }  // conn.close() called
}
 
// Combining with traditional catch/finally
public void combinedForm() throws IOException {
    try (var reader = new BufferedReader(new FileReader("data.txt"))) {
        processContent(reader.readLine());
    } catch (FileNotFoundException e) {
        // Handle specific exception
        handleMissingFile();
    } catch (IOException e) {
        // Handle other I/O errors
        logAndRethrow(e);
    } finally {
        // Runs AFTER close() has been called
        // Useful for additional cleanup or logging
        logOperationComplete();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

// What you write:
try (FileInputStream fis = new FileInputStream("file.txt")) {
    processFile(fis);
}
 
// What the compiler generates (conceptually):
{
    FileInputStream fis = new FileInputStream("file.txt");
    Throwable primaryException = null;
    try {
        processFile(fis);
    } catch (Throwable t) {
        primaryException = t;
        throw t;
    } finally {
        if (fis != null) {
            if (primaryException != null) {
                try {
                    fis.close();
                } catch (Throwable suppressed) {
                    // Key insight: exceptions from close() are SUPPRESSED
                    // not lost, and not replacing the primary exception
                    primaryException.addSuppressed(suppressed);
                }
            } else {
                fis.close();  // If no exception, close normally
            }
        }
    }
}
 
// Accessing suppressed exceptions:
try {
    try (var resource = acquireResource()) {
        throw new BusinessException("Primary Error");
    }
} catch (BusinessException e) {
    System.out.println("Primary: " + e.getMessage());
    
    Throwable[] suppressed = e.getSuppressed();
    for (Throwable t : suppressed) {
        System.out.println("Suppressed: " + t.getMessage());
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82

using System;
using System.IO;
using System.Data.SqlClient;
 
// Traditional using statement
public void ReadFile(string path)
{
    using (StreamReader reader = new StreamReader(path))
    {
        string line;
        while ((line = reader.ReadLine()) != null)
        {
            ProcessLine(line);
        }
    }  // reader.Dispose() called here
}
 
// Multiple resources - various nesting styles
public void CopyFile(string source, string dest)
{
    // Stacked using statements (older style)
    using (FileStream sourceStream = File.OpenRead(source))
    using (FileStream destStream = File.Create(dest))
    {
        sourceStream.CopyTo(destStream);
    }  // Both disposed in reverse order
}
 
// C# 8.0+ using declarations (scope-based)
public void ModernStyle(string path)
{
    using var reader = new StreamReader(path);  // No braces!
    
    // reader is disposed at end of enclosing scope
    string content = reader.ReadToEnd();
    ProcessContent(content);
    
    // Other code...
    
}  // reader disposed here, at end of method
 
// Combining using declarations with other statements
public async Task ProcessDataAsync(string connectionString)
{
    await using var connection = new SqlConnection(connectionString);
    await connection.OpenAsync();
    
    await using var command = connection.CreateCommand();
    command.CommandText = "SELECT * FROM Users";
    
    await using var reader = await command.ExecuteReaderAsync();
    while (await reader.ReadAsync())
    {
        yield return new User
        {
            Id = reader.GetInt32(0),
            Name = reader.GetString(1)
        };
    }
}  // reader, command, connection all disposed asynchronously
 
// IAsyncDisposable for async cleanup (C# 8.0+)
public class AsyncDatabaseConnection : IAsyncDisposable
{
    private SqlConnection _connection;
    
    public async ValueTask DisposeAsync()
    {
        if (_connection != null)
        {
            await _connection.CloseAsync();
            await _connection.DisposeAsync();
        }
    }
}
 
// Usage with await using
public async Task UseAsyncResource()
{
    await using var db = new AsyncDatabaseConnection();
    await db.QueryAsync("SELECT 1");
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

// The canonical Dispose pattern
public class ResourceHolder : IDisposable
{
    // Managed resources (other IDisposable objects)
    private FileStream _fileStream;
    private SqlConnection _connection;
    
    // Unmanaged resources (handles, pointers)
    private IntPtr _unmanagedHandle;
    
    // Track disposal state
    private bool _disposed = false;
    
    // Constructor
    public ResourceHolder(string filePath, string connectionString)
    {
        _fileStream = new FileStream(filePath, FileMode.Open);
        _connection = new SqlConnection(connectionString);
        _unmanagedHandle = NativeMethods.AllocateHandle();
    }
    
    // Public Dispose method - called by users
    public void Dispose()
    {
        Dispose(disposing: true);
        
        // Tell GC not to call finalizer - we already cleaned up
        GC.SuppressFinalize(this);
    }
    
    // Protected virtual method - can be overridden by derived classes
    protected virtual void Dispose(bool disposing)
    {
        if (_disposed)
            return;
            
        if (disposing)
        {
            // Dispose managed resources
            // These have their own Dispose methods
            _fileStream?.Dispose();
            _connection?.Dispose();
        }
        
        // Always dispose unmanaged resources
        // (whether called from Dispose or finalizer)
        if (_unmanagedHandle != IntPtr.Zero)
        {
            NativeMethods.FreeHandle(_unmanagedHandle);
            _unmanagedHandle = IntPtr.Zero;
        }
        
        _disposed = true;
    }
    
    // Finalizer - safety net for unmanaged resources only
    ~ResourceHolder()
    {
        // disposing: false means only clean up unmanaged resources
        // Managed resources might already be finalized!
        Dispose(disposing: false);
    }
    
    // Methods should check disposed state
    public void DoWork()
    {
        if (_disposed)
            throw new ObjectDisposedException(nameof(ResourceHolder));
            
        // ... actual work ...
    }
}
 
// Simpler pattern for managed-only resources (C# 8.0+)
public sealed class SimpleManagedResource : IDisposable
{
    private FileStream _stream;
    private bool _disposed;
    
    public void Dispose()
    {
        if (!_disposed)
        {
            _stream?.Dispose();
            _disposed = true;
        }
    }
    // No finalizer needed - no unmanaged resources
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106

# Built-in file objects are context managers
with open('data.txt', 'r') as f:
    content = f.read()
    process(content)
# f.close() called automatically
 
 
# Multiple context managers in one with statement
with open('input.txt') as src, open('output.txt', 'w') as dst:
    for line in src:
        dst.write(line.upper())
# Both files closed
 
 
# Custom context manager class
class DatabaseConnection:
    """Context manager for database connections."""
    
    def __init__(self, connection_string):
        self.connection_string = connection_string
        self.connection = None
    
    def __enter__(self):
        """Acquire resource and return it (or a proxy)."""
        self.connection = psycopg2.connect(self.connection_string)
        return self.connection  # This is bound to 'as' variable
    
    def __exit__(self, exc_type, exc_val, exc_tb):
        """Release resource. Handle or propagate exceptions."""
        if self.connection:
            if exc_type is not None:
                # An exception occurred - rollback
                self.connection.rollback()
            self.connection.close()
        
        # Return False (or None) to propagate exceptions
        # Return True to suppress the exception
        return False  
 
 
# Usage
with DatabaseConnection('postgresql://localhost/mydb') as conn:
    cursor = conn.cursor()
    cursor.execute('SELECT * FROM users')
    users = cursor.fetchall()
# Connection automatically closed, with rollback on error
 
 
# Transaction manager with commit on success
class Transaction:
    def __init__(self, connection):
        self.connection = connection
        self.cursor = None
    
    def __enter__(self):
        self.cursor = self.connection.cursor()
        return self.cursor
    
    def __exit__(self, exc_type, exc_val, exc_tb):
        if exc_type is None:
            # No exception - commit
            self.connection.commit()
        else:
            # Exception occurred - rollback
            self.connection.rollback()
        self.cursor.close()
        return False  # Don't suppress exceptions
 
 
# Nested context managers for complex scenarios
with DatabaseConnection(conn_str) as conn:
    with Transaction(conn) as cursor:
        cursor.execute('INSERT INTO logs VALUES (%s)', (message,))
# Transaction committed, connection closed
 
 
# Exception suppression example
class SuppressingLockManager:
    """Silently handles lock acquisition failure."""
    
    def __init__(self, lock):
        self.lock = lock
        self.acquired = False
    
    def __enter__(self):
        try:
            self.acquired = self.lock.acquire(timeout=1.0)
        except LockError:
            self.acquired = False
        return self
    
    def __exit__(self, exc_type, exc_val, exc_tb):
        if self.acquired:
            self.lock.release()
        
        # Suppress LockError but not other exceptions
        if exc_type is LockError:
            return True  # Suppress
        return False  # Propagate
 
 
with SuppressingLockManager(lock) as mgr:
    if mgr.acquired:
        do_work()
    else:
        log("Lock unavailable, skipping")

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

from contextlib import contextmanager, closing, suppress, ExitStack
 
# @contextmanager decorator - generator-based context managers
@contextmanager
def managed_connection(connection_string):
    """Create a context manager using a generator."""
    connection = psycopg2.connect(connection_string)
    try:
        yield connection  # What __enter__ returns
    except Exception:
        connection.rollback()
        raise
    else:
        connection.commit()
    finally:
        connection.close()  # Always runs
 
 
# Usage
with managed_connection('postgresql://localhost/mydb') as conn:
    conn.execute('INSERT INTO users VALUES (%s)', ('Alice',))
 
 
# @contextmanager for temporary state changes
@contextmanager  
def temporary_directory_change(new_dir):
    """Temporarily change working directory."""
    old_dir = os.getcwd()
    os.chdir(new_dir)
    try:
        yield
    finally:
        os.chdir(old_dir)
 
 
with temporary_directory_change('/tmp'):
    # Working directory is /tmp here
    create_temp_files()
# Back to original directory
 
 
# closing() - adapt any object with close() method
from urllib.request import urlopen
 
with closing(urlopen('https://example.com')) as page:
    content = page.read()
# page.close() called
 
 
# suppress() - cleanly ignore specific exceptions
from contextlib import suppress
 
with suppress(FileNotFoundError):
    os.remove('might_not_exist.txt')
# No exception raised if file doesn't exist
 
 
# ExitStack - manage dynamic number of context managers
from contextlib import ExitStack
 
def process_all_files(file_paths):
    with ExitStack() as stack:
        # Dynamically open all files
        files = [stack.enter_context(open(fp)) for fp in file_paths]
        
        # All files are open here
        for f in files:
            process(f.read())
    # ALL files automatically closed
 
 
# Async context managers (Python 3.7+)
from contextlib import asynccontextmanager
 
@asynccontextmanager
async def managed_async_connection(url):
    connection = await aiohttp.connect(url)
    try:
        yield connection
    finally:
        await connection.close()
 
 
async def fetch_data():
    async with managed_async_connection('wss://api.example.com') as ws:
        await ws.send('hello')
        response = await ws.receive()
# Connection closed after block

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

// Kotlin's use() extension function - cleaner than Java's try-with-resources
 
// Basic usage - any Closeable/AutoCloseable
fun readFile(path: String): String {
    val file = File(path)
    return file.bufferedReader().use { reader ->
        reader.readText()
    }  // reader.close() called
}
 
// use() returns the lambda's result
fun processData(): List<User> {
    return File("users.json").inputStream().use { stream ->
        JsonParser.parse(stream)
    }
}
 
// Multiple resources - nested use()
fun copyFile(source: Path, dest: Path) {
    Files.newInputStream(source).use { input ->
        Files.newOutputStream(dest).use { output ->
            input.copyTo(output)
        }
    }  // Both closed in reverse order
}
 
// Custom use-like extension for any resource
inline fun <T : AutoCloseable?, R> T.useWith(block: (T) -> R): R {
    var exception: Throwable? = null
    try {
        return block(this)
    } catch (e: Throwable) {
        exception = e
        throw e
    } finally {
        when {
            this == null -> {}
            exception == null -> close()
            else -> try { 
                close() 
            } catch (closeException: Throwable) {
                exception.addSuppressed(closeException)
            }
        }
    }
}
 
// Kotlin scope functions complement use()
fun executeQuery(sql: String): List<Row> {
    return dataSource.connection.use { conn ->
        conn.prepareStatement(sql).use { stmt ->
            stmt.executeQuery().use { rs ->
                generateSequence { if (rs.next()) rs.toRow() else null }
                    .toList()
            }
        }
    }
}
 
// Coroutine-aware resource management
suspend fun asyncOperation() {
    val resource = acquireResource()
    try {
        useResourceAsync(resource)
    } finally {
        withContext(NonCancellable) {
            resource.close()  // Cleanup even if coroutine cancelled
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

// Well-designed AutoCloseable implementation
public class ManagedDatabaseSession implements AutoCloseable {
    private final Connection connection;
    private final List<PreparedStatement> statements = new ArrayList<>();
    private final List<ResultSet> resultSets = new ArrayList<>();
    private boolean closed = false;
    
    public ManagedDatabaseSession(DataSource dataSource) throws SQLException {
        // Acquire resource in constructor
        this.connection = dataSource.getConnection();
        this.connection.setAutoCommit(false);
    }
    
    public PreparedStatement prepare(String sql) throws SQLException {
        checkOpen();
        PreparedStatement stmt = connection.prepareStatement(sql);
        statements.add(stmt);  // Track for cleanup
        return stmt;
    }
    
    public ResultSet executeQuery(PreparedStatement stmt) throws SQLException {
        checkOpen();
        ResultSet rs = stmt.executeQuery();
        resultSets.add(rs);  // Track for cleanup
        return rs;
    }
    
    public void commit() throws SQLException {
        checkOpen();
        connection.commit();
    }
    
    public void rollback() throws SQLException {
        checkOpen();
        connection.rollback();
    }
    
    @Override
    public void close() throws SQLException {
        if (closed) return;  // Idempotent
        
        closed = true;
        SQLException exceptions = null;
        
        // Close in reverse order of acquisition
        // ResultSets first
        for (int i = resultSets.size() - 1; i >= 0; i--) {
            try {
                resultSets.get(i).close();
            } catch (SQLException e) {
                if (exceptions == null) exceptions = e;
                else exceptions.addSuppressed(e);
            }
        }
        
        // Then statements
        for (int i = statements.size() - 1; i >= 0; i--) {
            try {
                statements.get(i).close();
            } catch (SQLException e) {
                if (exceptions == null) exceptions = e;
                else exceptions.addSuppressed(e);
            }
        }
        
        // Finally connection
        try {
            connection.close();
        } catch (SQLException e) {
            if (exceptions == null) exceptions = e;
            else exceptions.addSuppressed(e);
        }
        
        if (exceptions != null) throw exceptions;
    }
    
    private void checkOpen() {
        if (closed) {
            throw new IllegalStateException("Session is closed");
        }
    }
}
 
// Usage
try (var session = new ManagedDatabaseSession(dataSource)) {
    PreparedStatement stmt = session.prepare("SELECT * FROM users WHERE id = ?");
    stmt.setLong(1, userId);
    ResultSet rs = session.executeQuery(stmt);
    
    while (rs.next()) {
        process(rs);
    }
    
    session.commit();
}  // Everything closed: rs, stmt, connection

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

// Pattern: Loan Pattern - provide resource for callback duration
public <T> T withConnection(Function<Connection, T> operation) throws SQLException {
    try (Connection conn = dataSource.getConnection()) {
        return operation.apply(conn);
    }
}
 
// Usage - caller never sees the resource lifecycle
String result = withConnection(conn -> {
    PreparedStatement stmt = conn.prepareStatement("SELECT name FROM users WHERE id = ?");
    stmt.setLong(1, userId);
    ResultSet rs = stmt.executeQuery();
    return rs.next() ? rs.getString(1) : null;
});
 
 
// Pattern: Resource Factory returning AutoCloseable wrapper
public AutoCloseable createTrackedResource() {
    NativeResource resource = NativeResource.allocate();
    return () -> {
        resource.free();
        metrics.recordRelease();
    };
}
 
 
// Pattern: Composite resource managing multiple sub-resources
public class ResourceBundle implements AutoCloseable {
    private final List<AutoCloseable> resources = new ArrayList<>();
    
    public <T extends AutoCloseable> T add(T resource) {
        resources.add(resource);
        return resource;
    }
    
    @Override
    public void close() throws Exception {
        Exception first = null;
        for (int i = resources.size() - 1; i >= 0; i--) {
            try {
                resources.get(i).close();
            } catch (Exception e) {
                if (first == null) first = e;
                else first.addSuppressed(e);
            }
        }
        if (first != null) throw first;
    }
}
 
// Usage
try (ResourceBundle bundle = new ResourceBundle()) {
    Connection conn = bundle.add(dataSource.getConnection());
    FileInputStream fis = bundle.add(new FileInputStream("data.txt"));
    // Use both resources
}  // Both closed properly
 
 
// Pattern: Conditional resource acquisition
public void processWithOptionalCache(String key) throws Exception {
    Cache cache = cacheEnabled ? new Cache() : null;
    try {
        if (cache != null) {
            // Use cache
        }
        // Process
    } finally {
        if (cache != null) {
            cache.close();
        }
    }
}
 
// Better with try-with-resources for optional:
try (Cache cache = cacheEnabled ? new Cache() : null) {
    // Works! null resources are safely handled
}
 
 
// Pattern: Transfer ownership
public FileInputStream transferOwnership() {
    FileInputStream fis = new FileInputStream("data.txt");
    // Successfully created - transfer ownership to caller
    // Caller is now responsible for closing
    return fis;
}
 
// Pattern: Wrapper that takes ownership
public class OwnedInputStream implements AutoCloseable {
    private final InputStream delegate;
    private final boolean ownsDelegate;
    
    public OwnedInputStream(InputStream delegate, boolean ownsDelegate) {
        this.delegate = delegate;
        this.ownsDelegate = ownsDelegate;
    }
    
    @Override
    public void close() throws IOException {
        if (ownsDelegate) {
            delegate.close();
        }
    }
}