Android开发者Hanlder避免内存泄漏，采用静态内部类+弱引用的方式(非静态内部类导致内存泄露)

非静态内部类（包括匿名内部类）默认就会持有外部类的引用，当非静态内部类对象的生命周期 比外部类对象的生命周期长时，就会导致内存泄露。

非静态内部类导致的内存泄露在 Android 开发中有一种典型的场景就是使用 Handler，很多开发 者在使用 Handler 是这样写的：

public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
start();
}
private void start() {
Message msg = Message.obtain();
msg.what = 1;
mHandler.sendMessage(msg);
}
private Handler mHandler = new Handler() {
@Override
public void handleMessage(Message msg) {
if (msg.what == 1) {
//
做 相 应 逻 辑
}
}
};
}

也许有人会说， mHandler 并未作为静态变量持有 Activity 引用，生命周期可能不会比 Activity 长， 应该不一定会导致内存泄露呢，显然不是这样的！
熟悉 Handler 消息机制的都知道，mHandler 会作为成员变量保存在发送的消息 msg 中，即 msg 持有 mHandler 的引用，而 mHandler 是 Activity 的非静态内部类实例，即 mHandler 持有 Activity 的引 用，那么我们就可以理解为 msg 间接持有 Activity 的引用。msg 被发送后先放到消息队列 MessageQueue 中，然后等待 Looper 的轮询处理（MessageQueue 和 Looper 都是与线程相关联的， MessageQueue 是 Looper 引用的成员变量，而 Looper 是保存在 ThreadLocal 中的）。那么当 Activity 退出后，msg 可能仍然存在于消息对列 MessageQueue 中未处理或者正在处理，那么这样就会导致 Activity 无法被回收，以致发生 Activity 的内存泄露。
通常在 Android 开发中如果要使用内部类，但又要规避内存泄露，一般都会采用静 态 内 部 类 + 弱引 用 的方式。

public class MainActivity extends AppCompatActivity {
private Handler mHandler;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
mHandler = new MyHandler(this);
start();
}
private void start() {
Message msg = Message.obtain();
msg.what = 1;
mHandler.sendMessage(msg);
}
private static class MyHandler extends Handler {
private WeakReference<MainActivity> activityWeakReference;
public MyHandler(MainActivity activity) {
activityWeakReference = new WeakReference<>(activity);
}
@Override
public void handleMessage(Message msg) {
MainActivity activity = activityWeakReference.get();
if (activity != null) {
if (msg.what == 1) {
//
做 相 应 逻 辑
}
}
}
}
}

mHandler 通过弱引用的方式持有 Activity，当 GC 执行垃圾回收时，遇到 Activity 就会回收并释 放所占据的内存单元。这样就不会发生内存泄露了。
上面的做法确实避免了 Activity 导致的内存泄露，发送的 msg 不再已经没有持有 Activity 的引用 了，但是 msg 还是有可能存在消息队列 MessageQueue 中，所以更好的是在 Activity 销毁时就将 mHandler 的回调和发送的消息给移除掉。

@Overrideprotected void onDestroy() {
super.onDestroy();
mHandler.removeCallbacksAndMessages(null);
}

非静态内部类造成内存泄露还有一种情况就是使用 Thread 或者 AsyncTask。

比如在 Activity 中直接 new 一个子线程 Thread：

public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
new Thread(new Runnable() {
@Override
public void run() {
//
模 拟 相 应 耗 时 逻 辑
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}).start();
}

或者直接新建 AsyncTask 异步任务：

public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
new AsyncTask<Void, Void, Void>() {
@Override
protected Void doInBackground(Void... params) {
//
模 拟 相 应 耗 时 逻 辑
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
return null;
}
}.execute();
}
}

这种方式新 建的子线程 Thread 和 AsyncTask 都是匿名内部类对象，默认就隐式的持有外部 Activity 的引用， 导致 Activity 内存泄露。要避免内存泄露的话还是需要像上面 Handler 一样使用 静 态 内 部 类 + 弱 应 用 的方式（代码就不列了，参考上面 Hanlder 的正确写法）。

及格写法

 private final Handler handler = new Handler(new Handler.Callback() {
        @Override
        public boolean handleMessage(Message msg) {
            return false;
        }
    });