Java – A reference counting pattern for memory managed languages

cdesign-patternsgarbage-collectionjavareference-counting

Java and .NET have wonderful garbage collectors that manage memory for you, and convenient patterns for quickly releasing external objects (Closeable, IDisposable), but only if they are owned by a single object. In some systems a resource might need to be consumed independently by two components, and only be released when both components release the resource.

In modern C++ you would solve this problem with a shared_ptr, which would deterministically release the resource when all the shared_ptr's are destroyed.

Are there any documented, proven patterns for managing and releasing expensive resources that don't have a single owner in object oriented, non-deterministically garbage collected systems?

Best Answer

In general, you avoid it by having a single owner - even in unmanaged languages.

But the principle is the same for managed languages. Instead of immediately closing the expensive resource on a Close() you decrement a counter (incremented on Open()/Connect()/etc) until you hit 0 at which point the close actually does the close. It'll likely look and act like the Flyweight Pattern.

Related Solutions

How common are circular references? Would reference-counting GC work just fine

Weak references work great for breaking loops, as long as it's clear a loop is being made and as long as the developer makes provision for it with a weak reference. This isn't the same as a more robust GC, which is intended to handle such things automatically so the developer doesn't have to think about them at all.

Java – Why did memory-managed languages like Java, Javascript, and C# retain the `new` keyword

Your observations are correct. C++ is a complicated beast, and the new keyword was used to distinguish between something that needed delete later and something that would be automatically reclaimed. In Java and C#, they dropped the delete keyword because the garbage collector would take care of it for you.

The problem then is why did they keep the new keyword? Without talking to the people who wrote the language it's kind of difficult to answer. My best guesses are listed below:

It was semantically correct. If you were familiar with C++, you knew that the new keyword creates an object on the heap. So, why change expected behavior?
It calls attention to the fact that you are instantiating an object rather than calling a method. With Microsoft code style recommendations, method names start with capital letters so there can be confusion.

Ruby is somewhere in between Python and Java/C# in it's use of new. Basically you instantiate an object like this:

f = Foo.new()

It's not a keyword, it's a static method for the class. What that means is that if you want a singleton, you can override the default implementation of new() to return the same instance every time. It's not necessarily recommended, but it's possible.

Best Answer

Related Solutions

How common are circular references? Would reference-counting GC work just fine

Java – Why did memory-managed languages like Java, Javascript, and C# retain the `new` keyword

Related Topic