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

1. 有“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++");    }}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

内存泄漏分析

　　执行一次跳转到StaticReferenceActivity界面并退出。执行onDestroy()方法，则该界面被销毁。 StaticReferenceActivity界面被销毁，则它对应用程序不再有用。它所占用的的资源，应该被释放。但是StaticReferenceActivity不能被垃圾回收的原因，有名为sStaticReferenceActivity的变量引用着StaticReferenceActivity的实例。查看程序，我们发现sStaticReferenceActivity是一个静态变量。我们知道静态变量会被存储在静态存储区中，而静态存储区中的数据在应用程序运行时一直存在。 

　　很多朋友在编写Java程序时，为了方便喜欢使用静态变量，它虽然方便，但使用不当确容易产生内存泄漏，所以本人建议，合理进行程序设计，尽量少用static变量。

2.使用“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++");    }}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

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++");    }}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

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

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

使用方法EventBus.getDefault().register(this);将EventBusActivity的实例注册到了EventBus，但在EventBusActivity退出时却未进行反注册。 
解决该种内存泄漏，只需在onDestroy()方法中，调用EventBus.getDefault().unregister(this);进行反注册。

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

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;    }}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

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

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

解决该中内存泄漏的方法，在不使用资源时，调用资源的销毁方法，对其进行清理和销毁。

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

我们知道内部类和匿名内部类中持有外部类的引用，所以内部类的实例不能释放，将导致外部类的实例不能释放，发生内存泄漏。