Android常见内存泄漏和LeakCanary的使用

App有内存泄漏就是埋了一颗定时炸弹, 累积多了终将导致OOM. 下面列举一些常见导致内存泄漏的代码.

未注销导致的内存泄漏

使用了广播, EventBus等等, 会导致Activity无法被GC回收

@Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_common);
        EventBus.getDefault().register(this);
    }

    @Subscribe
    public void onEvent(MessageEvent msg) {

    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        //未移除注册的EventBus
//        EventBus.getDefault().unregister(this);
    }

非静态内部类使用不当导致的内存泄漏

非静态内部类会持有外部类引用, 如果Activity中包含了静态的内部类成员就会导致内存泄漏

private static InnerClass mInnerClass;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_common);
        mInnerClass = new InnerClass();
    }

    //非静态内部类持有外部类引用
    public class InnerClass {
        private String msg;

        public InnerClass() {
        }

    }

匿名类使用不当导致的内存泄漏

@Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_common);
        //匿名类持有外部类引用
        new AsyncTask<Void, Void, Void>() {

            @Override
            protected Void doInBackground(Void... params) {
                for (int i = 0; i < 10; i++) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                return null;
            }
        }.execute();
    }

工具类使用不当导致的内存泄漏

@Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_common);
        String s = Util.getInstance(this).doSomething();
    }

public class Util {
    private volatile static Util instance;
    private static Context mContext;

    private Util(Context context) {
        mContext = context;
    }
//传进来的context被静态持有
    public static Util getInstance(Context context) {
        if (instance == null) {
            synchronized (Util.class) {
                if (instance == null) {
                    instance = new Util(context);
                }
            }
        }
        return instance;
    }

    public static String doSomething() {
        String string = mContext.getResources().getString(R.string.app_name);
        return string;
    }
}

写Util的时需要Context的时候, 判断一下, 如果可以用ApplicationContext优先使用.
可以用ApplicationContext的情况下在Application里面加上一个getInstance()方法, 就不用传Context进来了.

public class App extends Application {
    private static App instance;

    public static App getInstance() {
        return instance;
    }

    @Override
    public void onCreate() {
        super.onCreate();
        instance = this;
    }
}

线程使用不当导致的内存泄漏

 @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_common);
        //Activity实例被Runnable持有, Runnable传入l一个异步线程，
        // 此线程和此Acitivity生命周期不一致的时候，就造成了Activity的泄露。
        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) ;
            }
        }).start();
    }

Handle使用不当导致的内存泄漏

 private Handler mLeakyHandler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);

        }
    };

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_common);
        //Handler 为非静态内部类，它会持有外部类的引用
        mLeakyHandler.postDelayed(new Runnable() {
            @Override
            public void run() {
                //doSomething
            }
        }, 1000 * 20);
    }

静态集合使用不当导致的内存泄漏

 @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_common);
        ActivityCollector.addActivity(this);
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        //静态集合没有移除元素
//        ActivityCollector.removeActivity(this);
    }

public class ActivityCollector {

    public static List<Activity> activities = new ArrayList<Activity>();

    public static void addActivity(Activity activity) {
        activities.add(activity);
    }

    public static void removeActivity(Activity activity) {
        activities.remove(activity);
    }
}

使用弱引用避免内存泄漏

在 Activity 中避免使用非静态内部类，比如上面我们将 Handler 声明为静态的，则其存活期跟 Activity 的生命周期就无关了。同时通过弱引用的方式引入 Activity，避免直接将 Activity 作为 context 传进去

public class WeakReferenceActivity extends AppCompatActivity {

    //将 Handler 声明为静态 没有了Activity的引用, 无法直接引用其变量或方法,
    // 使用弱引用WeakReference来解决这个问题
    private static class DBHandler extends Handler {

        //弱引用, 而不是使用外部类this或者传进来
        private final WeakReference<WeakReferenceActivity> mActivity;

        public DBHandler(WeakReferenceActivity activity) {
            mActivity = new WeakReference<>(activity);
        }

        @Override
        public void handleMessage(Message msg) {
            WeakReferenceActivity activity = mActivity.get();
            if (activity != null) {
                Toast.makeText(activity, "what: " + msg.what, Toast.LENGTH_SHORT).show();
            }
        }

    }

    private final DBHandler mHandler = new DBHandler(this);

    private static final Runnable sRunnable = new Runnable() {
        @Override
        public void run() {
            Toast.makeText(App.getInstance(), "sRunnable run()", Toast.LENGTH_SHORT).show();
        }
    };

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_weak_reference);
        mHandler.postDelayed(sRunnable, 1000 * 20);
    }

    public void onClick(View view) {
        mHandler.sendEmptyMessage(new Random().nextInt(10));
    }
}

LeakCanary的使用

• build.gradle dependencies{…}添加

    //https://github.com/square/leakcanary
    debugCompile 'com.squareup.leakcanary:leakcanary-android:1.5'
    releaseCompile 'com.squareup.leakcanary:leakcanary-android-no-op:1.5'
    testCompile 'com.squareup.leakcanary:leakcanary-android-no-op:1.5'

• Application配置

public class App extends Application {
    private static App instance;
    private static RefWatcher sRefWatcher;

    public static RefWatcher getRefWatcher() {
        return sRefWatcher;
    }

    public static App getInstance() {
        return instance;
    }

    @Override
    public void onCreate() {
        super.onCreate();
        if (LeakCanary.isInAnalyzerProcess(this)) {
            // This process is dedicated to LeakCanary for heap analysis.
            // You should not init your app in this process.
            return;
        }
        sRefWatcher = LeakCanary.install(this);
        // Normal app init code...
        instance = this;
    }
}

• AndroidManifest.xml

<application
    android:name="yourApp"
    android:allowBackup="true"
    android:icon="@mipmap/ic_launcher"
    android:label="@string/app_name"
    android:supportsRtl="true"
    android:theme="@style/AppTheme">
</application>

检测Fragment内存泄漏

public class LeakFragment extends Fragment {

    @Nullable
    @Override
    public View onCreateView(LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
        View view = inflater.inflate(R.layout.activity_common, container, false);
        return view;
    }

    @Override
    public void onActivityCreated(@Nullable Bundle savedInstanceState) {
        super.onActivityCreated(savedInstanceState);
        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) ;
            }
        }).start();
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        //onDestroy中添加
        App.getRefWatcher().watch(this);
    }
}