weak-references

I recently came across a piece of Java code with WeakReferences - I had never seen them deployed although I'd come across them when they were introduced. Is this something that should be routinely used or only when one runs into memory problems? If the latter, can they be easily retrofitted or does the code need serious refactoring? Can the average Java (or C#) programmer generally ignore them? EDIT Can any damage be done by over-enthusiastic use of WRs? Weak references are all about garbage collection. A standard object will not "disappear" until all references to it are severed, this means

I understand that weak references are at the mercy of the garbage collector, and we cannot guarantee that the weak reference will exist. I could not see a need to have weak reference, but sure there should be a reason. Why do we need weak reference in java? What are the practical (some) uses of weak reference in java? If you can share how you used in your project it will be great! It's actually quite often a bad idea to use weak hashmaps. For one it's easy to get wrong, but even worse it's usually used to implement some kind of cache. What this does mean is the following: Your program runs

So I've been mulling over some automatic memory management ideas lately - specifically, I've been looking at implementing a memory manager based on reference counting. Of course, everyone knows that circular references kill naive reference counting. The solution: weak references. Personally, I hate using weak references in this way (there are other more intuitive ways of dealing with this, via cycle detection), but it got me thinking: where else could a weak reference be useful? I figure that there must be some reason they exist, especially in languages with tracing garbage collection, which

I have a question regarding this simple frequently occurring situation in android . We have a main activity , we invoke an AsyncTask alongwith the reference of the mainactivity , so that that the AsyncTask can update the views on the MainActivity. I will break down the event into steps MainActivity creates an AyncTask , passes its reference to it . AysncTask , starts it's work , downloading ten files for example The user changed the orientation of the device. This results in an orphan pointer in the AsyncTask When the AsyncTask completes , and tries to access the activity to update the status

I am trying to figure out a way to use typeof to create a weak reference to self for use in blocks to avoid retain cycles. When I first read about this it seems that the convention was to use __block typeof(self) bself = self; , which compiles but using __block to avoid retain cycles doesn't work anymore and __weak should be used instead. However __weak typeof(self) bself = self; results in an error: The type 'typeof (self)' (aka 'TUAccountsViewController *const __strong') already has retainment attributes set on it Is there a way to use typeof or another call to generically create a weak

i have a cache that uses WeakReferences to the cached objects to make them automatically removed from the cache in case of memory pressure. My problem is that the cached objects are collected very soon after they have been stored in the cache. The cache runs in a 64-Bit application and in spite of the case that more than 4gig of memory are still available, all the cached objects are collected (they usually are stored in the G2-heap at that moment). There are no garbage collection induced manually as the process explorer shows. What methods can i apply to make the objects live a litte longer?