Do not do anything wrong with Android to cause memory leakage

InAndroidContext can perform many operations, but the main function is to load and access resources. There are two kinds of context in android, one is application context and the other is activity context. Generally, activity context is transmitted between different types and methods, for example, onCreate of an activity.

Java code:

 
 

  
  
Protected void onCreate (Bundle state ){
  
  
Super. onCreate (state );
  
  
TextView label = new TextView (this); // pass context to view control
  
  
Label. setText ("Leaks are bad ");
  
  
SetContentView (label );
  
  
}
 
 

Passing the activity context to the view means that the view has a reference pointing to the activity and then referencing the resources occupied by the activity: view hierachy and resource.

In this way, if the context memory leaks, a lot of memory will be leaked.

This vulnerability indicates that gc cannot recycle activity memory.

Leaking an entire activity is an easy task.

When the screen rotates, the system destroys the current activity, saves the status information, and creates a new one.

For example, if we write an application that needs to load a large image, we do not want to destroy the image and reload it every time we rotate the screen. The simple idea of implementing this requirement is to define a static Drawable, so that the Activity class creation and destruction is always stored in the memory.

Implementation is similar:

Java code:

 
 

  
  
public class myactivity extends Activity {   
  
  
private static Drawable sBackground;   
  
  
protected void onCreate(Bundle state) {   
  
  
super.onCreate(state);   
  
  
TextView label = new TextView(this);   
  
  
label.setText("Leaks are bad");   
  
  
if (sBackground == null) {   
  
  
sBackground = getDrawable(R.drawable.large_bitmap);   
  
  
}   
  
  
label.setBackgroundDrawable(sBackground);//drawable attached to a view   
  
  
setContentView(label);   
  
  
}   
  
  
}  
 
 

This program looks very simple, but it has a big problem. When the screen is rotated, there will be a leak, that is, the gc cannot destroy the activity ). As we said earlier, when the screen is rotated, the system will destroy the current activity. However, when drawable is associated with the view, drawable saves the view reference, that is, sBackground saves the label reference, while the label stores the reference of the activity. Since drawable cannot be destroyed and neither referenced nor indirectly referenced by it can be destroyed, the system cannot destroy the current activity, resulting in Memory leakage. Gc is powerless for this type of Memory leakage.

To avoid Memory leakage, you can avoid any activity whose lifecycle is longer than that of the activity, and prevent the activity from being destroyed due to its reference to the activity. We can use application context. Application context is associated with the life cycle of the application and has nothing to do with the life cycle of the activity.Application contextYou can useContext. getApplicationContextOrActivity. getApplicationMethod.

To avoid Memory leakage related to context, remember the following points:

1. Do not make an object with a long life cycle reference the activity context. That is, ensure that the object that references the activity has the same life cycle as the activity itself.

2. For objects with a long life cycle, you can use application context.

3. Avoid non-static internal classes and try to use static classes to avoid lifecycle issues. Pay attention to the lifecycle changes caused by internal class references to external objects.

Insert a new Activity in Android Development

Android development: Passing values between activities

Android Activity and Intent mechanism learning notes

Android development: Custom GridView/ListView Data Source