Android异常优化之内存泄露实例与及部分解决方案

1.Java内存泄漏基础知识

  内存泄漏的理解其实很简单，就是该被释放的对象没有被释放，一直被某个或者某些实例引用所持有，导致不能被垃圾回收。

1）Java内存的分配策略：

  a.静态存储区（方法区）：跟堆一样，被所有的线程共享。方法区包含所有的class和static变量，方法区中包含的都是在整个程序中永远唯一的元素，如class，static变量。

  b.栈区：每个线程包含一个栈区，栈中只保存基础数据类型的对象和自定义对象的引用(不是对象)，对象都存放在堆区中，每个栈中的数据(原始类型和对象引用)都是私有的，其他栈不能访问，栈分为3个部分：基本类型变量区、执行环境上下文、操作指令区(存放操作指令)。

  c.堆区：动态内存分配，new出来的对象都存放在此区域，没用的对象都会被GC进行回收。存储的全部是对象，每个对象都包含一个与之对应的class的信息。(class的目的是得到操作指令) ，jvm只有一个堆区(heap)被所有线程共享，堆中不存放基本类型和对象引用，只存放对象本身
 

2、Java当中的内存泄露

       在Java中，内存泄漏就是存在一些被分配的对象，这些对象有下面两个特点，首先，这些对象是可达的，即在有向图中，存在通路可以与其相连（也就是说仍存在该内存对象的引用）；其次，这些对象是无用的，即程序以后不会再使用这些对象。如果对象满足这两个条件，这些对象就可以判定为Java中的内存泄漏，这些对象不会被GC所回收，然而它却占用内存。简单来说就是无用对象（不再使用的对象）持续占有内存或者无用对象得不到及时的释放，从而造成内存空间的浪费叫内存泄漏。
 

3、Android中的内存泄露

    1.单例造成的内存泄漏

public class SingletonActivityContext {
    private static SingletonActivityContext instance;
    private Context context;

    private SingletonActivityContext(Context context) {
        this.context = context;
    }

    public static SingletonActivityContext getInstance(Context context) {
        if (instance == null) {
            instance = new SingletonActivityContext(context);
        }
        return instance;
    }
}

正确写法应该是：

public class SingletonActivityContext {
    private static SingletonActivityContext instance;
    private Context context;

    private SingletonActivityContext(Context context) {
        this.context = context.getApplicationContext(); //使用Application的context
    }

    public static SingletonActivityContext getInstance(Context context) {
        if (instance == null) {
            instance = new SingletonActivityContext(context);
        }
        return instance;
    }
}

2.非静态内部类创建静态实例造成的内存泄漏

public class StaticLeakActivity extends Activity {
    private static noneStaticClass mResource = null;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        if (mResource == null) {
            mResource = new noneStaticClass();
        }
    }

    private class noneStaticClass {

    }
}

解决：

public class StaticLeakActivity extends Activity {
    private static noneStaticClass mResource = null;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        if (mResource == null) {
            mResource = new noneStaticClass();
        }
    }

     //修改为静态内部类，这样就不会持有外部类的引用了
    private static class noneStaticClass {

    }
}

3.handler造成内存泄漏

public class HandlerLeakActivity extends Activity {
    private final Handler mLeakyHandler = new Handler() {
        @Override
        public void handleMessage(Message msg) {

        }
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        mLeakyHandler.postDelayed(new Runnable() {
            @Override
            public void run() {
            }
        }, 1000 * 60 * 10);

        finish();
    }
    /*
    * 解决办法：
    * 1.将 Handler 声明为静态的
    * 2.通过弱引用的方式引入 Activity
    * 3.并在Acitivity的onDestroy()中调用handler.removeCallbacksAndMessages(null)及时移除所有消息。
    *
    * */
}

解决示例：

public class HandlerLeakActivity extends Activity {

   private MyHandler mleakHandler = new MyHandler(this)
    //1、修改为静态内部类    
    private static class MyHandler extends Handler {
        //2.通过弱引用的方式引入 Activity
        private WeakReference<Context> reference;
        
        public MyHandler(Context context){
            reference = new WeakReference<>(context);
        }

        @Override
        public void handleMessage(Message msg) {
            HandlerLeakActivity activity = (HandlerLeakActivity)reference.get();
            if(activity!=null){
                //todo业务逻辑
            }
        }
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        mLeakyHandler.postDelayed(new Runnable() {
            @Override
            public void run() {
            }
        }, 1000 * 60 * 10);

        finish();
    }

    @Override
    public void onDestroy() {
       mLeakyHandler.removeCallbacksAndMessages(null);

    }
}

4.线程造成的内存泄漏

public class ThreadLeakActivity extends Activity {
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        testThreadLeak();
    }

    private void testThreadLeak() {
        new AsyncTask<Void, Void, Void>() {
            @Override
            protected Void doInBackground(Void... params) {
                SystemClock.sleep(10000);
                return null;
            }
        }.execute();

        new Thread(new Runnable() {
            @Override
            public void run() {
                SystemClock.sleep(10000);
            }
        }).start();
    }

    static class MyAsyncTask extends AsyncTask<Void, Void, Void> {
        private WeakReference<Context> weakReference;

        public MyAsyncTask(Context context) {
            weakReference = new WeakReference<>(context);
        }

        @Override
        protected Void doInBackground(Void... params) {
            SystemClock.sleep(10000);
            return null;
        }

        @Override
        protected void onPostExecute(Void aVoid) {
            super.onPostExecute(aVoid);
            ThreadLeakActivity activity = (ThreadLeakActivity) weakReference.get();
            if (activity != null) {
                //...
            }
        }
    }

    static class MyRunnable implements Runnable {
        @Override
        public void run() {
            SystemClock.sleep(10000);
        }
    }
}

5.Webview造成的内存泄漏

public class WebviewLeakActivity extends AppCompatActivity {
    private WebView mWebView;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        mWebView = (WebView) findViewById(R.id.wv_show);
        mWebView.loadUrl("http://www.baidu.com");
    }


    @Override
    protected void onDestroy() {
        destroyWebView();
        //解决
        //放在单独进程中，退出杀掉进程
        android.os.Process.killProcess(android.os.Process.myPid());
        super.onDestroy();
    }

    private void destroyWebView() {
        if (mWebView != null) {
            mWebView.pauseTimers();
            mWebView.removeAllViews();
            mWebView.destroy();
            mWebView = null;
        }
    }

}

6.资源未关闭造成的内存泄漏

7.Bitmap内存泄漏，使用recycle方法回收