weak-references

Here's my use case. We are trying to narrow down a potential memory leak in an application, and we are using a memory analysis tool to snapshot the heap so we can look for object instances and references. (In case it helps, we're using YourKit.) This application makes extensive use of dynamic and CGLIB proxies, which end up storing tons of references to classes and classloaders in WeakHashMaps. After our test case runs, we are expecting all hard references to object X and its classloader to be gone, but since there were many proxies involved in the test case in the end we have many weak/soft

I'm implementing a cache for Objects stored persistently. The idea is: Method getObjectFromPersistence(long id); ///Takes about 3 seconds Method getObjectFromCache(long id) //Instantly And have a method: getObject(long id) with the following pseudocode: synchronized(this){ CustomObject result= getObjectFromCache(id) if (result==null){ result=getObjectFromPersistence(id); addToCache(result); } return result; } But I need to allow the CustomObject to be collected by the garbage collector. Until now I was using an HashMap<Long,WeakReference<CustomObject> for the implementation. The problem is

I'd like to verify that code setting up a WeakReference does not accidentally hold a strong reference to the referenced object. (Here's an example of how it is easy to accidentally do this.) Does this look like the best way to check for inadvertent strong references? TestObject testObj = new TestObject(); WeakReference wr = new WeakReference(testObj); // Verify that the WeakReference actually points to the intended object instance. Assert.Equals(wr.Target, testObject); // Force disposal of testObj; testObj = null; GC.Collect(); // If no strong references are left to the wr.Target, wr.IsAlive

In one of the projects I take part in there is a vast use of WeakAction . That's a class that allows to keep reference to an action instance without causing its target not be garbage collected. The way it works is simple, it takes an action on the constructor, and keeps a weak reference to the action's target and to the Method but discards the reference to the action itself. When the time comes to execute the action, it checks if the target is still alive, and if so, invokes the method on the target. It all works well except for one case - when the action is instantiated in a closure. consider

I have gone through the article http://developer.android.com/resources/articles/avoiding-memory-leaks.html . In this article it is suggested to use static inner class with Weak Reference . public class GalleryVideo extends Activity { private int AUDIO_NO = 1; ........................... ................ @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); gallery = (Gallery) findViewById(R.id.examplegallery); gallery.setAdapter(new AddImgAdp(this)); } static public class AddImgAdp extends BaseAdapter { private int GalItemBg; private Context cont;

I have a block wherein I use self so I declare a weak reference to self: __weak MyClass *weakSelf = self; Now my questions: I get an error where I define weakSelf and I don't understand what this should mean.: weak attribute can not be specified on an automatic variable Inside my block I pass weakSelf to another block and I am not sure if I now have to do the same thing again like so: __weak MyClass *weakWeakSelf = weakSelf; And then pass weakWeakSelf to that block? This is most likely occurring as you are targeting down to iOS 4. You should change it to be __unsafe_unretained MyClass

To avoid a memory leak I wrote the following method that will be used in activities and mainly in fragments (using inheritance). That method is supposed to allow me to never directly refer to the activity by calling //this or getActivity() The method is: private WeakReference<BaseActivity> activityWeakReference = null; public BaseActivity getActivityFromWeakReference(){ activityWeakReference = activityWeakReference == null ? new WeakReference<BaseActivity>((BaseActivity)getActivity()) : activityWeakReference; return activityWeakReference.get(); } Is calling this method