内存泄漏是指内存空间使用完毕后无法被释放的现象。尽管Java有垃圾回收机制（GC），但是对于还保持着引用，逻辑上却已经不会再用到的对象，垃圾回收器不会回收它们。
内存泄漏带来的危害：
被 static 关键字修饰的成员变量的生命周期等于应用程序的生命周期。若使被 static 关键字修饰的成员变量引用耗费资源过多的实例（如Context），则容易出现该成员变量的生命周期大于引用实例生命周期的情况，当引用实例需结束生命周期销毁时，会因静态变量的持有而无法被回收，从而出现内存泄露。
解决方案：
非静态内部类 / 匿名类默认持有外部类的引用，而静态内部类则不会。常见的情况有以下三种。
如果非静态内部类所创建的实例是静态的，其生命周期等于应用的生命周期。非静态内部类默认持有外部类的引用而导致外部类无法释放，最终造成内存泄露。即外部类中持有非静态内部类的静态对象。
public class MainActivity extends AppCompatActivity {
//非静态内部类的静态实例引用
public static InnerClass innerClass = null;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
//保证非静态内部类的实例只有1个
if (innerClass == null) {
innerClass = new InnerClass();
}
}
// 非静态内部类
private class InnerClass {
//...
}
}
当 MainActivity 销毁时，因非静态内部类单例的引用，innerClass 的生命周期等于应用的生命周期，持有外部类 MainActivity 的引用，故 MainActivity 无法被 GC 回收，从而导致内存泄漏。
解决方案：
当工作线程正在处理任务时，如果外部类销毁， 由于工作线程实例持有外部类引用，将使得外部类无法被垃圾回收器（GC）回收，从而造成内存泄露。
public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
startAsyncTask();
}
private void startAsyncTask() {
new AsyncTask<Void, Void, Void>() {
@Override
protected Void doInBackground(Void... voids) {
//执行耗时操作
while(true);
}
}.execute();
}
}
public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
MyRunnable myRunnable = new MyRunnable();
Thread thread = new Thread(myRunnable);
thread.start();
}
class MyRunnable implements Runnable {
@Override
public void run() {
//执行耗时操作
}
}
}
public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
new MyThread().start();
}
private class MyThread extends Thread {
@Override
public void run() {
//执行耗时操作
}
}
}
解决方案：
private static class MyThread extends Thread {
@Override
public void run() {
//执行耗时操作
}
}
@Override
protected void onDestroy() {
super.onDestroy();
myThread.interrupt();
}
在 Handler 消息队列还有未处理的消息 / 正在处理消息时，消息队列中的 Message 持有 Handler 实例的引用。如果 Handler 是非静态内部类 / 匿名内部类（2种使用方式），就会默认持有外部类的引用（如 MainActivity 实例）。
上述的引用关系会一直保持，直到 Handler 消息队列中的所有消息被处理完毕。在 Handler 消息队列还有未处理的消息 / 正在处理消息时，此时若需销毁外部类 MainActivity，但由于上述引用关系，垃圾回收器（GC）无法回收 MainActivity，从而造成内存泄漏。
public class MainActivity extends AppCompatActivity {
private MyHandler myHandler;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
myHandler = new MyHandler();
new Thread() {
@Override
public void run() {
try {
//执行耗时操作
Thread.sleep(10000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//发送消息
myHandler.sendEmptyMessage(1);
}
}.start();
}
private class MyHandler extends Handler {
@Override
public void handleMessage(Message msg) {
//处理消息事件
}
}
}
解决方案：
public class MainActivity extends AppCompatActivity {
private MyHandler myHandler;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
myHandler = new MyHandler(this);
new Thread() {
@Override
public void run() {
try {
//执行耗时操作
Thread.sleep(10000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//发送消息
myHandler.sendEmptyMessage(1);
}
}.start();
}
public void test() {
Log.d("MainActivity", "test");
}
private static class MyHandler extends Handler {
//定义弱引用实例
private WeakReference<Activity> reference;
//在构造方法中传入需持有的Activity实例
public MyHandler(Activity activity) {
//使用 WeakReference 弱引用持有 Activity 实例
reference = new WeakReference<Activity>(activity);
}
@Override
public void handleMessage(Message msg) {
//处理消息事件
//调用Activity实例中的方法
((MainActivity) reference.get()).test();
}
}
}
使用建议：
为了保证 Handler 中消息队列中的所有消息都能被执行，此处推荐使用解决方案1，即静态内部类+弱引用的方式。
对于资源的使用（如广播 BraodcastReceiver、文件流 File、数据库游标 Cursor、图片资源 Bitmap等），若在 Activity 销毁时无及时关闭 / 注销这些资源，则这些资源将不会被回收，从而造成内存泄漏。
解决方案：
//对于广播BroadcastReceiver：注销注册
unregisterReceiver(broadcastReceiver);
//对于文件流File：关闭流
inputStream / outputStream.close();
//对于数据库游标cursor：使用后关闭游标
cursor.close();
//对于图片资源Bitmap：Android分配给图片的内存只有8M，若1个Bitmap对象占内存较多，当它不再被使用时，应调用recycle()回收此对象的像素所占用的内存；最后再赋为null
bitmap.recycle();
bitmap = null;
// 对于动画（属性动画），将动画设置成无限循环播放setRepeatCount(ValueAnimator.INFINITE);后
// 在Activity退出时记得停止动画
animator.cancel();
关闭以上对象的时候注意做非空判断。
WebView 内部的一些线程持有 Activity 对象，使得 Activity 无法释放，从而导致内存泄漏。
解决方案：
@Override
protected void onDestroy() {
if (mWebView != null) {
ViewParent parent = mWebView.getParent();
if (parent != null) {
((ViewGroup) parent).removeView(mWebView);
}
mWebView.stopLoading();
mWebView.getSettings().setJavaScriptEnabled(false);
mWebView.clearHistory();
mWebView.clearView();
mWebView.removeAllViews();
mWebView.destroy();
mWebView = null;
}
super.onDestroy();
}
不建议在 xml 中创建 WebView，因为在 xml 中创建的 WebView 会持有 Activity 的 Context 对象。
由于单例的静态特性使得其生命周期跟应用的生命周期一样长，所以如果使用不恰当的话，很容易造成内存泄漏。
public class Singleton {
private static Singleton instance;
private Context mContext;
private Singleton(Context context){
this.mContext = context;
}
public static Singleton getInstance(Context context){
if (instance == null){
synchronized (Singleton.class){
if (instance == null){
instance = new Singleton(context);
}
}
}
return instance;
}
}
这是一个单例模式，当创建这个单例的时候，由于需要传入一个 Context：
解决方案：
将 new Singleton(context) 改为 new Singleton(context.getApplicationContext()) 即可，这样便和传入的 Activity 没关系了。
public class Singleton {
private static Singleton instance;
private Context mContext;
private Singleton(Context context){
this.mContext = context;
}
public static Singleton getInstance(Context context){
if (instance == null){
synchronized (Singleton.class){
if (instance == null){
instance = new Singleton(context.getApplicationContext());// 使用Application 的context
}
}
}
return instance;
}
}
lint 是一个静态代码分析工具，同样也可以用来检测部分会出现内存泄露的代码，平时编程注意 lint 提示的各种黄色警告即可。如：
也可以手动检测，在 Android Studio 中选择 Analyze->Inspect Code。
然后会弹出弹窗选择检测范围。
点击 OK 等待分析结果：
这个工具除了会检测内存泄漏，还会检测代码是否规范、是否有没用到的导包、可能的bug、安全问题等等。