Memory leak of java.util.ref.Finalizer while Finalizer thread is waiting

Question

Analysing a heap dump I look for instances of java.lang.ref.Finalizer class. java.lang.ref.Finalizer has 'next' and 'prev' member fields for maintaining linked list. I always get FileInputStream as a tail of the list and FileOutputStream as previous entry to it (analysed several heap dumps). File descriptors for FileInputStream and FileOutputStream are always 0 and 1 respectively:

+---[Pending Finalization] java.lang.ref.Finalizer           
| |                                                          
| +---queue  java.lang.ref.ReferenceQueue [Stack Local]      
| |                                                          
| +---referent  java.io.FileInputStream                     
| | |                                                        
| | +---closed = boolean false                               
| | |                                                        
| | +---closeLock  java.lang.Object                          
| | |                                                        
| | +---fd  java.io.FileDescriptor                           
| |   |                                                      
| |   +---closed = boolean false                             
| |   |                                                      
| |   +---fd = int 0                                         
| |   |                                                       
| |   +---parent  java.io.FileInputStream                    
| |                                                          
| +---prev  [Pending Finalization] java.lang.ref.Finalizer   
|   |                                                        
|   +---queue  java.lang.ref.ReferenceQueue [Stack Local]    
|   |                                                        
|   +---next  [Pending Finalization] java.lang.ref.Finalizer 
|   |                                                        
|   +---referent  java.io.FileOutputStream                   
|   | |                                                      
|   | +---append = boolean false                             
|   | |                                                      
|   | +---closed = boolean false                             
|   | |                                                       
|   | +---closeLock  java.lang.Object                        
|   | |                                                     
|   | +---fd  java.io.FileDescriptor                         
|   |   |                                                    
|   |   +---closed = boolean false                           
|   |   |                                                    
|   |   +---fd = int 1  0x00000001                           
|   |   |                                                    
|   |   +---parent  java.io.FileOutputStream                 
|   |                                                         
|   +---prev  [Pending Finalization] java.lang.ref.Finalizer

Why always FileInputStream and FileOutputStream are at the tail of the ReferenceQueue?
Aren't they collected by garbage collector because I observe only Allocation Failure GC not Full GC occuring?
Why descriptors are always 0 and 1 for them?

You are leaking file input and output streams. Solution: don't. — user207421
@user207421, unfortunately, your reply does not look like an answer to neither of the 3 questions. — pnt_of_view

Holger Holger · Accepted Answer · 2019-02-22T09:55:53

Maybe the following test program will shed some light on it:

Field fd = FileDescriptor.class.getDeclaredField("fd");
fd.setAccessible(true);
System.out.println("stdin:  "+fd.get(FileDescriptor.in));
System.out.println("stdout: "+fd.get(FileDescriptor.out));
System.out.println("stderr: "+fd.get(FileDescriptor.err));

stdin:  0
stdout: 1
stderr: 2

^{Ideone, Note that for JDK 8, this applies to Unix like systems only}

In other words, you are looking at the file streams encapsulated by System.in and System.out and, of course, these will never get garbage-collected and usually, you also don’t call close() on them.

The finalization does not support any kind of opt-out, so any instance of a class with a “non trivial finalize() method” will get a finalizer reference upon construction, even when the creator knows that the object will never get finalized.

The most recent JDK versions use a Cleaner for this purpose, which allows not to register a cleaner when a FileInputStream or FileOutputStream is constructed using an existing FileDescriptor, which is the case for stdin and stdout. It also allows immediate cleaning and hence deregistration in the close() method, not needing any post-mortem cleanup for well behaved programs.

So with the newest Java versions, you should see only cleaners for streams actually in use in the heap dump.

Memory leak of java.util.ref.Finalizer while Finalizer thread is waiting

1 Answers