Android中常出现的内存泄漏情况分析

Android中常出现的内存泄漏情况分析

@(内存)

• 有static变量引用待释放类实例
• 使用Handler向MessageQueue中添加需要等待的任务
• 对需要进行注册的对象，进行了注册，但未进行反注册
• 单例中持有了待释放对象的引用
• 内部类和匿名内部类中有外部类的引用，由于它们被引用导致外部类对象不能被释放
• 具有销毁方法的资源在使用完后，没有调用相应方法对资源进行销毁。
• Service执行完任务，不对其立即进行销毁

下面通过实例来对上面可能导致内存泄漏的各种情况进行说明。

有“static”变量引用待释放类实例

示例代码

public class StaticReferenceActivity extends AppCompatActivity {    private static final String NAME = StaticReferenceActivity.class.getSimpleName();    private static final String TAG = "sxd";    public static StaticReferenceActivity sStaticReferenceActivity;    @Override    protected void onCreate(@Nullable Bundle savedInstanceState) {        super.onCreate(savedInstanceState);        setContentView(R.layout.activity_static_reference);        sStaticReferenceActivity = this;    }    @Override    protected void onDestroy() {        super.onDestroy();        Log.i(TAG, NAME + "--onDestroy++");    }}

内存泄漏分析

　　执行一次跳转到StaticReferenceActivity界面并退出。执行onDestroy()方法，则该界面被销毁。

　　StaticReferenceActivity界面被销毁，则它对应用程序不再有用。它所占用的的资源，应该被释放。但当使用Memory Analyzer工具分析后，发现内存中仍有StaticReferenceActivity实例不能被GC掉。

　　Memory Analyzer给我们指出了StaticReferenceActivity不能被垃圾回收的原因，有名为sStaticReferenceActivity的变量引用着StaticReferenceActivity的实例。查看程序，我们发现sStaticReferenceActivity是一个静态变量。我们知道静态变量会被存储在静态存储区中，而静态存储区中的数据在应用程序运行时一直存在。
　　很多朋友在编写Java程序时，为了方便喜欢使用静态变量，它虽然方便，但使用不当确容易产生内存泄漏，所以本人建议，合理进行程序设计，尽量少用static变量。

使用“Handler”向“MessageQueue”中添加需要等待的任务

示例代码

public class HandlerActivity extends AppCompatActivity {    private static final String NAME = HandlerActivity.class.getSimpleName();    private static final String TAG = "sxd";    private Handler mHandler;    @Override    protected void onCreate(@Nullable Bundle savedInstanceState) {        super.onCreate(savedInstanceState);        setContentView(R.layout.activity_handler);        initData();    }    private void initData() {        mHandler = new Handler();        mHandler.postDelayed(new Runnable() {            @Override            public void run() {                Log.i(TAG, NAME + "--5分钟后执行的任务++");            }        }, 5 * 60 * 1000);    }    @Override    protected void onDestroy() {        super.onDestroy();        Log.i(TAG, NAME + "--onDestroy++");    }}

内存泄漏分析

　　执行一次跳转到HandlerActivity 界面并退出。执行onDestroy()方法，则该界面被销毁。

　　HandlerActivity 界面被销毁，则它对应用程序不再有用。它所占用的的资源，应该被释放。但当使用Memory Analyzer工具分析后，发现内存中仍有HandlerActivity 实例不能被GC掉。

　　Memory Analyzer给我们指出了HandlerActivity 不能被垃圾回收的原因，有名为mMessageQueue的变量引用着HandlerActivity 的实例。查看示例代码，我们发现我们用Handler向MessageQueue中加入了一个任务，但该任务要延迟5分钟才能执行，所以在改任务未被处理前，它将一直持有HandlerActivity的实例。导致HandlerActivity界面退出后，其占用内存不能被立即释放掉。所以要在退出HandlerActivity界面时，将任务移出MessageQueue。

处理内存泄漏的代码

public class HandlerActivity extends AppCompatActivity {    private static final String NAME = HandlerActivity.class.getSimpleName();    private static final String TAG = "sxd";    private Handler mHandler;    private Runnable mRunnable;    @Override    protected void onCreate(@Nullable Bundle savedInstanceState) {        super.onCreate(savedInstanceState);        setContentView(R.layout.activity_handler);        initData();    }    private void initData() {        mHandler = new Handler();        mRunnable = new Runnable() {            @Override            public void run() {                Log.i(TAG, NAME + "--5分钟后执行的任务++");            }        };        mHandler.postDelayed(mRunnable, 5 * 60 * 1000);    }    @Override    protected void onDestroy() {        super.onDestroy();        mHandler.removeCallbacks(mRunnable);        Log.i(TAG, NAME + "--onDestroy++");    }}

　　示例程序所表现的问题并不严重，因为等待5分钟后，这部分内存依旧可以释放掉。但如果使用Handler实现了循环定时器，如果在不使用后，忘记将任务从MessageQueue中移出，那这部分内存在程序运行期间将永不会被释放。

对需要进行注册的对象，进行了“注册”，但未进行“反注册”

　　现在很多项目都使用EventBus进行事件的分发/订阅。所以以它的使用为例，说明对象未进行反注册引发的内存泄漏。

示例代码

public class EventBusActivity extends AppCompatActivity implements View.OnClickListener {    private static final String NAME = EventBusActivity.class.getSimpleName();    private static final String TAG = "sxd";    private TextView mTextView;    private Button mButton;    @Override    protected void onCreate(@Nullable Bundle savedInstanceState) {        super.onCreate(savedInstanceState);        setContentView(R.layout.activity_eventbus);        initView();    }    private void initView() {        mTextView = (TextView) this.findViewById(R.id.textview);        mButton = (Button) this.findViewById(R.id.button);        mButton.setOnClickListener(this);        EventBus.getDefault().register(this);    }    @Override    public void onClick(View v) {        switch (v.getId()) {            case R.id.button :                sendEventBus();                break;        }    }    private void sendEventBus() {        Event event = new Event();        event.setContent("EventBus未进行反注册泄漏");        EventBus.getDefault().post(event);    }    public void onEventMainThread(Event event) {        mTextView.setText(event.getContent());    }    @Override    protected void onDestroy() {        super.onDestroy();        Log.i(TAG, NAME + "--onDestroy++");    }    /**     * 发送事件     */    class Event {        String content;        public String getContent() {            return content;        }        public void setContent(String content) {            this.content = content;        }    }}

内存泄漏分析

　　执行一次跳转到EventBusActivity 界面并退出。执行onDestroy()方法，则该界面被销毁。

　　EventBusActivity 界面被销毁，则它对应用程序不再有用。它所占用的的资源，应该被释放。但当使用Memory Analyzer工具分析后，发现内存中仍有EventBusActivity 实例不能被GC掉。

　　Memory Analyzer给我们指出了EventBusActivity 不能被垃圾回收的原因，有名为EventBus的对象引用着。查看示例代码，我们发现我们使用方法EventBus.getDefault().register(this);将EventBusActivity的实例注册到了EventBus，但在EventBusActivity退出时却未进行反注册。
　　解决该种内存泄漏，只需在onDestroy()方法中，调用EventBus.getDefault().unregister(this);进行反注册。

“单例”中持有了待释放对象的引用

示例代码

public class Instance {    private static Instance sInstance;    private Context mContext;    private Instance(Context context) {        mContext = context;    }    public static synchronized Instance getInstance(Context context) {        if (sInstance == null) {            sInstance = new Instance(context);        }        return sInstance;    }}

public class InstanceActivity extends AppCompatActivity {    private static final String NAME = InstanceActivity.class.getSimpleName();    private static final String TAG = "sxd";    @Override    protected void onCreate(@Nullable Bundle savedInstanceState) {        super.onCreate(savedInstanceState);        setContentView(R.layout.activity_instance);        initData();    }    private void initData() {        Instance.getInstance(this);    }    @Override    protected void onDestroy() {        super.onDestroy();        Log.i(TAG, NAME + "--onDestroy++");    }}

内存泄漏分析

　　执行一次跳转到InstanceActivity 界面并退出。执行onDestroy()方法，则该界面被销毁。

　　InstanceActivity 界面被销毁，则它对应用程序不再有用。它所占用的的资源，应该被释放。但当使用Memory Analyzer工具分析后，发现内存中仍有InstanceActivity 实例不能被GC掉。

　　Memory Analyzer给我们指出了InstanceActivity 不能被垃圾回收的原因，在Instance实例中，有名为mContext的引用。查看示例代码，我们发现我们用InstanceActivity的实例初始化了Instance单例。我们知道单例对象是在应用程序运行时一直存在的。所以导致InstanceActivity对象不能释放。
　　这种内存泄漏的解决方法是，不要用待释放对象去初始化单例对象，单例对象最好使用ApplicationContext去初始化。所以示例程序内存泄漏的解决方法，将Instance.getInstance(this);改为Instance.getInstance(this.getApplicationContext());。

“内部类”和“匿名内部类”中有外部类的引用，由于它们被引用导致外部类对象不能被释放

示例代码

public interface Listener {    void listener();}

public class Instance {    private static Instance sInstance;    private Context mContext;    private Listener mListener;    private Instance(Context context) {        mContext = context;    }    public static synchronized Instance getInstance(Context context) {        if (sInstance == null) {            sInstance = new Instance(context);        }        return sInstance;    }    public void setListener(Listener listener) {        mListener = listener;    }}

public class InnerClassActivity extends AppCompatActivity {    private static final String NAME = InnerClassActivity.class.getSimpleName();    private static final String TAG = "sxd";    @Override    protected void onCreate(@Nullable Bundle savedInstanceState) {        super.onCreate(savedInstanceState);        setContentView(R.layout.activity_inner_class);        initData();    }    private void initData() {        Instance.getInstance(this.getApplicationContext()).setListener(new Listener() {            @Override            public void listener() {            }        });    }    @Override    protected void onDestroy() {        super.onDestroy();        Log.i(TAG, NAME + "--onDestroy++");    }}

public class InnerClassActivity extends AppCompatActivity {    private static final String NAME = InnerClassActivity.class.getSimpleName();    private static final String TAG = "sxd";    @Override    protected void onCreate(@Nullable Bundle savedInstanceState) {        super.onCreate(savedInstanceState);        setContentView(R.layout.activity_inner_class);        initData();    }    private void initData() {        Instance.getInstance(this.getApplicationContext()).setListener(new MyListener());    }    @Override    protected void onDestroy() {        super.onDestroy();        Log.i(TAG, NAME + "--onDestroy++");    }    class MyListener implements Listener {        @Override        public void listener() {        }    }}

内存泄漏分析

　　执行一次跳转到InnerClassActivity 界面并退出。执行onDestroy()方法，则该界面被销毁。

　　InnerClassActivity 界面被销毁，则它对应用程序不再有用。它所占用的的资源，应该被释放。但当使用Memory Analyzer工具分析后，发现内存中仍有InnerClassActivity 实例不能被GC掉。

　　Memory Analyzer给我们指出了InnerClassActivity 不能被垃圾回收的原因，在Instance实例中，有名为mListener的InnerClassActivity 内部类实例引用着。查看示例代码，我们发现我们将内部类或匿名内部类对象设置到了Instance单例中，导致InnerClassActivity 内部类的实例在程序运行期间始终被引用，不能释放。我们知道内部类和匿名内部类中持有外部类的引用，所以内部类的实例不能释放，将导致外部类的实例不能释放，发生内存泄漏。

具有销毁方法的“资源”在使用完后，没有调用相应方法对资源进行销毁

示例代码

public class BaiduMapActivity extends AppCompatActivity {    private static final String NAME = BaiduMapActivity.class.getSimpleName();    private static final String TAG = "sxd";    private MapView mBaiduMapView;    private BaiduMap mBaiduMap;    @Override    protected void onCreate(@Nullable Bundle savedInstanceState) {        super.onCreate(savedInstanceState);        setContentView(R.layout.activity_baidumap);        initView();    }    private void initView() {        mBaiduMapView = (MapView) this.findViewById(R.id.mapview);        //地图初始化        mBaiduMapView.showScaleControl(false);        mBaiduMapView.showZoomControls(false);        mBaiduMap = mBaiduMapView.getMap();        mBaiduMap.setMapType(BaiduMap.MAP_TYPE_NORMAL);//普通地图    }    @Override    protected void onDestroy() {        super.onDestroy();        Log.i(TAG, NAME + "--onDestroy++");    }}

内存泄漏分析

　　执行一次跳转到BaiduMapActivity 界面并退出。执行onDestroy()方法，则该界面被销毁。

　　BaiduMapActivity 界面被销毁，则它对应用程序不再有用。它所占用的的资源，应该被释放。但当使用Memory Analyzer工具分析后，发现内存中仍有BaiduMapActivity 实例不能被GC掉。

　　Memory Analyzer给我们指出了BaiduMapActivity 不能被垃圾回收的原因，百度地图中仍有资源引用着。查看示例代码，我们发现，我们使用了百度地图，却没有在BaiduMapActivity 界面退出时，对使用的百度地图资源进行销毁。
解决该中内存泄漏的方法，在不使用资源时，调用资源的销毁方法，对其进行清理和销毁。该示例程序中，只需在onDestroy()方法中，调用方法mBaiduMap.clear(); mBaiduMapView.onDestroy();对百度地图资源进行销毁。

源码地址