Real-World Impact: Database and File Handles
What you'll learn: How resource leaks in production systems lead to catastrophic failures like connection pool exhaustion and file descriptor limits.
The Real Cost of Resource Leaks
In toy examples, forgetting to close a resource might seem harmless. In production systems, it's a ticking time bomb. Every leaked database connection or file handle consumes a finite system resource that never gets reclaimed until your application crashes.
Connection Pool Exhaustion
Most applications use a connection pool—a fixed-size collection of database connections (often 10-50 connections). When you forget to close a connection, it stays "checked out" forever. Once all connections are leaked, new requests hang indefinitely waiting for an available connection. Your entire application grinds to a halt, even though the database itself is perfectly healthy.
Think of it like a library with 20 copies of a popular book. If borrowers never return them, eventually no one else can check one out—even though the library building is fine.
File Descriptor Limits
Operating systems limit how many files a process can open simultaneously (often 1024 on Linux). Each unclosed FileInputStream, Socket, or ServerSocket consumes one descriptor. Leak enough, and suddenly your application cannot open any files—not even log files. Users see cryptic "Too many open files" errors.
Why Try-With-Resources Matters
These aren't theoretical problems. They're the leading cause of production outages in data-driven applications. Try-with-resources eliminates this entire class of bugs by guaranteeing that close() is called, even when exceptions occur. The alternative—manual cleanup in finally blocks—is so error-prone that it regularly fails in production.
Key Takeaway: Resource leaks aren't just memory issues—they exhaust connection pools and file descriptors, causing production outages. Try-with-resources prevents these critical failures automatically.