<h3>前言：</h3>    <p>最近公司C轮融资成功了，移动团队准备扩大一下，需要招聘Android开发工程师，陆陆续续面试了几位Android应聘者，面试过程中聊到性能优化中如何避免内存泄漏问题时，很少有人全面的回答上来。所以决定抽空学习总结一下这方面的知识，以及分享一下我们是如何检测内存泄漏的。我们公司使用开源框架LeakCanary来检测内存泄漏。</p>    <h3><strong>什么是内存泄漏？</strong></h3>    <p>有些对象只有有限的生命周期。当它们的任务完成之后，它们将被垃圾回收。如果在对象的生命周期本该结束的时候，这个对象还被一系列的引用，这就会导致内存泄漏。随着泄漏的累积，app将消耗完内存。</p>    <h3><strong>内存泄漏造成什么影响？</strong></h3>    <p>它是造成应用程序OOM的主要原因之一。由于android系统为每个应用程序分配的内存有限，当一个应用中产生的内存泄漏比较多时，就难免会导致应用所需要的内存超过这个系统分配的内存限额，这就造成了内存溢出而导致应用Crash。</p>    <h3><strong>什么是LeakCanary？</strong></h3>    <p>leakCanary是Square开源框架，是一个Android和Java的内存泄露检测库，如果检测到某个 activity 有内存泄露，LeakCanary 就是自动地显示一个通知，所以可以把它理解为傻瓜式的内存泄露检测工具。通过它可以大幅度减少开发中遇到的oom问题，大大提高APP的质量。</p>    <h3><strong>LeakCanary捕获常见内存泄漏以及解决办法</strong></h3>    <p><strong>1.）错误使用单例造成的内存泄漏</strong></p>    <p>在平时开发中单例设计模式是我们经常使用的一种设计模式，而在开发中单例经常需要持有Context对象，如果持有的Context对象生命周期与单例生命周期更短时，或导致Context无法被释放回收，则有可能造成内存泄漏，错误写法如下：</p>    <pre>  <code class="language-java">public class LoginManager {      private static LoginManager mInstance;      private Context mContext;        private LoginManager(Context context) {          this.mContext = context;      }          public static LoginManager getInstance(Context context) {          if (mInstance == null) {              synchronized (LoginManager.class) {                  if (mInstance == null) {                      mInstance = new LoginManager(context);                  }              }          }          return mInstance;      }        public void dealData() {      }    }  </code></pre>    <p>弱我们在一个Activity中调用的，然后关闭该Activity则会出现内存泄漏。</p>    <pre>  <code class="language-java">LoginManager.getInstance(this).dealData();  </code></pre>    <p>LeakCanary检测结果如下：</p>    <p style="text-align:center"><img src="https://simg.open-open.com/show/4736949ffe445f809ab9b8b467f490c0.jpg"></p>    <p>解决 办法要保证Context和AppLication的生命周期一样，修改后代码如下：</p>    <pre>  <code class="language-java">public class LoginManager {      private static LoginManager mInstance;      private Context mContext;        private LoginManager(Context context) {          this.mContext = context.getApplicationContext();      }          public static LoginManager getInstance(Context context) {          if (mInstance == null) {              synchronized (LoginManager.class) {                  if (mInstance == null) {                      mInstance = new LoginManager(context);                  }              }          }          return mInstance;      }        public void dealData() {      }    }  </code></pre>    <p><strong>2.）Handler造成的内存泄漏</strong></p>    <p>早些年Handler的使用频率还是蛮高的，它是工作线程与UI线程之间通讯的桥梁，只是现在大量开源框架对其进行了封装，我们这里模拟一种常见使用方式来模拟内存泄漏情形。</p>    <pre>  <code class="language-java">public class MainActivity extends AppCompatActivity {      private Handler mHandler = new Handler();      private TextView mTextView;        @Override      protected void onCreate(Bundle savedInstanceState) {          super.onCreate(savedInstanceState);          setContentView(R.layout.activity_main);          mTextView = (TextView) findViewById(R.id.text);//模拟内存泄露          mHandler.postDelayed(new Runnable() {              @Override              public void run() {                  mTextView.setText("lcj");              }          }, 3 * 60 * 1000);          finish();      }        @Override      protected void onDestroy() {          super.onDestroy();          LApplication.getRefWatcher().watch(this);      }  }  </code></pre>    <p>上述代码通过内部类的方式创建mHandler对象,此时mHandler会隐式地持有一个外部类对象引用这里就是MainActivity，当执行postDelayed方法时，该方法会将你的Handler装入一个Message，并把这条Message推到MessageQueue中，MessageQueue是在一个Looper线程中不断轮询处理消息，那么当这个Activity退出时消息队列中还有未处理的消息或者正在处理消息，而消息队列中的Message持有mHandler实例的引用，mHandler又持有Activity的引用，所以导致该Activity的内存资源无法及时回收，引发内存泄漏。</p>    <p>LeakCanary检测结果如下：</p>    <p style="text-align:center"><img src="https://simg.open-open.com/show/7d79a314f34c1f23c1a8aa608a08fc5c.jpg"></p>    <p>要想避免Handler引起内存泄漏问题，需要我们在Activity关闭退出的时候的移除消息队列中所有消息和所有的Runnable。上述代码只需在onDestroy()函数中调用mHandler.removeCallbacksAndMessages(null);就行了。</p>    <pre>  <code class="language-java">public class MainActivity1 extends AppCompatActivity {      private Handler mHandler = new Handler();      private TextView mTextView;        @Override      protected void onCreate(Bundle savedInstanceState) {          super.onCreate(savedInstanceState);          setContentView(R.layout.activity_main);          mTextView = (TextView) findViewById(R.id.text);          //模拟内存泄露          mHandler.postDelayed(new Runnable() {              @Override              public void run() {                  mTextView.setText("lcj");              }          }, 3 * 60 * 1000);          finish();      }        @Override      protected void onDestroy() {          super.onDestroy();          mHandler.removeCallbacksAndMessages(null);          LApplication.getRefWatcher().watch(this);      }  }  </code></pre>    <p><strong>3.)线程造成的内存泄漏</strong></p>    <p>最早时期的时候处理耗时操作多数都是采用Thread+Handler的方式，后来逐步被AsyncTask取代，直到现在采用RxJava的方式来处理异步。这里以AsyncTask为例，可能大部分人都会这样处理一个耗时操作然后通知UI更新结果：</p>    <pre>  <code class="language-java">public class MainActivity extends AppCompatActivity {      private AsyncTask<Void, Void, Integer> asyncTask;      private TextView mTextView;        @Override      protected void onCreate(Bundle savedInstanceState) {          super.onCreate(savedInstanceState);          setContentView(R.layout.activity_main);          mTextView = (TextView) findViewById(R.id.text);          testAsyncTask();          finish();      }        private void testAsyncTask() {          asyncTask = new AsyncTask<Void, Void, Integer>() {              @Override              protected Integer doInBackground(Void... params) {                  int i = 0;                  //模拟耗时操作                  while (!isCancelled()) {                      i++;                      if (i > 1000000000) {                          break;                      }                      Log.e("LeakCanary", "asyncTask---->" + i);                  }                  return i;              }                @Override              protected void onPostExecute(Integer integer) {                  super.onPostExecute(integer);                  mTextView.setText(String.valueOf(integer));              }          };          asyncTask.execute();        }        @Override      protected void onDestroy() {          super.onDestroy();          LApplication.getRefWatcher().watch(this);      }    }  </code></pre>    <p>对于上面的例子来说，在处理一个比较耗时的操作时，可能还没处理结束MainActivity就执行了退出操作，但是此时AsyncTask依然持有对MainActivity的引用就会导致MainActivity无法释放回收引发内存泄漏。</p>    <p>LeakCanary检测结果：</p>    <p style="text-align:center"><img src="https://simg.open-open.com/show/d73275c3364b190fcd72d94864f57b3a.jpg"></p>    <p>如何解决这种内存泄漏呢？在使用AsyncTask时，在Activity销毁时候也应该取消相应的任务AsyncTask.cancel()方法，避免任务在后台执行浪费资源，进而避免内存泄漏的发生。</p>    <pre>  <code class="language-java">public class MainActivity3 extends AppCompatActivity {      private AsyncTask<Void, Void, Integer> asyncTask;      private TextView mTextView;        @Override      protected void onCreate(Bundle savedInstanceState) {          super.onCreate(savedInstanceState);          setContentView(R.layout.activity_main);          mTextView = (TextView) findViewById(R.id.text);          testAsyncTask();          finish();      }        private void testAsyncTask() {          asyncTask = new AsyncTask<Void, Void, Integer>() {              @Override              protected Integer doInBackground(Void... params) {                  int i = 0;                  //模拟耗时操作                  while (!isCancelled()) {                      i++;                      if (i > 1000000000) {                          break;                      }                      Log.e("LeakCanary", "asyncTask---->" + i);                  }                  return i;              }                @Override              protected void onPostExecute(Integer integer) {                  super.onPostExecute(integer);                  mTextView.setText(String.valueOf(integer));              }          };          asyncTask.execute();        }        private void destroyAsyncTask() {          if (asyncTask != null && !asyncTask.isCancelled()) {              asyncTask.cancel(true);          }          asyncTask = null;      }        @Override      protected void onDestroy() {          super.onDestroy();          destroyAsyncTask();          LApplication.getRefWatcher().watch(this);      }    }  </code></pre>    <p><strong>4.）非静态内部类创建静态实例造成的内存泄漏</strong></p>    <p> 有时我们需要一个可以随着屏幕旋转的Activity，比如视频播放Activity，这时我们为了防止多次调用onCreate方法导致某些参数重新初始化，我们一般会选择创建一个内部类和一个静态实例来保存这些参数，比如以下实现：</p>    <pre>  <code class="language-java">public class MainActivity extends AppCompatActivity {      private static Config mConfig;        @Override      protected void onCreate(Bundle savedInstanceState) {          super.onCreate(savedInstanceState);          setContentView(R.layout.activity_main);          //模拟内存泄露          if (mConfig == null) {              mConfig = new Config();              mConfig.setSize(18);              mConfig.setTitle("老九门");          }          finish();      }          @Override      protected void onDestroy() {          super.onDestroy();          LApplication.getRefWatcher().watch(this);      }        class Config {          private int size;          private String title;            public int getSize() {              return size;          }            public void setSize(int size) {              this.size = size;          }            public String getTitle() {              return title;          }            public void setTitle(String title) {              this.title = title;          }      }  }  </code></pre>    <p>上述代码看着没有任何问题，其实内部类都会持有一个外部类引用，这里这个外部类就是MainActivity，然而内部类实例又是static静态变量其生命周期与Application生命周期一样，所以在MainActivity关闭的时候，内部类静态实例依然持有对MainActivity的引用，导致MainActivity无法被回收释放，引发内存泄漏。LeakCanary检测内存泄漏结果如下：</p>    <p style="text-align:center"><img src="https://simg.open-open.com/show/2d6db72ab92af06cc9a25535e3f3a870.jpg"></p>    <p>对于这种泄漏的解决办法就是将内部类改成静态内部类，不再持有对MainActivity的引用即可，修改后的代码如下：</p>    <pre>  <code class="language-java">public class MainActivity extends AppCompatActivity {      private static Config mConfig;        @Override      protected void onCreate(Bundle savedInstanceState) {          super.onCreate(savedInstanceState);          setContentView(R.layout.activity_main);          //模拟内存泄露          if (mConfig == null) {              mConfig = new Config();              mConfig.setSize(18);              mConfig.setTitle("老九门");          }          finish();      }          @Override      protected void onDestroy() {          super.onDestroy();          LApplication.getRefWatcher().watch(this);      }        static class Config {          private int size;          private String title;            public int getSize() {              return size;          }            public void setSize(int size) {              this.size = size;          }            public String getTitle() {              return title;          }            public void setTitle(String title) {              this.title = title;          }      }  }  </code></pre>    <p><strong>5.）资源未关闭造成的内存泄漏</strong></p>    <p>对于使用了BraodcastReceiver，ContentObserver，File，Cursor，Stream，Bitmap等资源的使用，应该在Activity销毁时及时关闭或者注销，否则这些资源将不会被回收，造成内存泄漏。例如获取媒体库图片地址代码在查询结束的时候一定要调用</p>    <p>Cursor 的关闭方法防止造成内存泄漏。</p>    <pre>  <code class="language-java">     String columns[] = new String[]{                  MediaStore.Images.Media.DATA, MediaStore.Images.Media._ID, MediaStore.Images.Media.TITLE, MediaStore.Images.Media.DISPLAY_NAME          };          Cursor cursor = this.getContentResolver().query(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, columns, null, null, null);          if (cursor != null) {              int photoIndex = cursor.getColumnIndexOrThrow(MediaStore.Images.Media.DATA);              //显示每张图片的地址，但是首先要判断一下，Cursor是否有值              while (cursor.moveToNext()) {                  String photoPath = cursor.getString(photoIndex); //这里获取到的就是图片存储的位置信息                  Log.e("LeakCanary", "photoPath---->" + photoPath);              }              cursor.close();          }  </code></pre>    <h3><strong>总结：</strong></h3>    <p>以上就是通过LeakCanary检测到的内存泄漏情况以及解决办法。</p>    <p> </p>    <p>来自：http://www.cnblogs.com/whoislcj/p/6001422.html</p>    <p> </p>