Android性能优化-内存泄漏的几个案例

作者: JC_Hou | 来源:发表于2018-01-05 10:58 被阅读51次

JVM内存管理

Java采用GC进行内存管理。深入的JVM内存管理知识，推荐《深入理解Java虚拟机》。

关于内存泄漏我们要知道，JVM内存分配的几种策略。

1. 静态的

静态的存储区，内存在程序编译的时候就已经分配好了，这块内存在程序整个运行期间都一直存在，它主要存放静态数据、全局的static数据和一些常量。

2.栈式的

在执行方法时，方法一些内部变量的存储都可以放在栈上面创建，方法执行结束的时候这些存储单元就会自动被注释掉。栈内存包括分配的运算速度很快，因为内在在处理器里面。当然容量有限，并且栈式一块连续的内存区域，大小是由操作系统决定的，他先进后出，进出完成不会产生碎片，运行效率高且稳定

3.堆式的

也叫动态内存。我们通常使用new 来申请分配一个内存。这里也是我们讨论内存泄漏优化的关键存储区。GC会根据内存的使用情况，对堆内存里的垃圾内存进行回收。

堆内存是一块不连续的内存区域，如果频繁地new/remove会造成大量的内存碎片，GC频繁的回收，导致内存抖动，这也会消耗我们应用的性能

我们知道可以调用 System.gc();进行内存回收，但是GC不一定会执行。

面对GC的机制，我们是否无能为力？其实我们可以通过声明一些引用标记来让GC更好对内存进行回收。

类型	回收时机	生命周期
StrongReference （强引用）	任何时候GC是不能回收他的，哪怕内存不足时，系统会直接抛出异常OutOfMemoryError，也不会去回收	进程终止
SoftReference （软引用）	当内存足够时不会回收这种引用类型的对象，只有当内存不够用时才会回收	内存不足，进行GC的时候
WeakReference （弱引用）	GC一运行就会把给回收了	GC后终止
PhantomReference (虚引用)	如果一个对象与虚引用关联，则跟没有引用与之关联一样，在任何时候都可能被垃圾回收器回收	任何时候都有可能

开发时，为了防止内存溢出，处理一些比较占用内存并且生命周期长的对象时，可以尽量使用软引用和弱引用。

Tip：成员变量全部存储在堆中（包括基本数据类型，引用及引用的对象实体），因为他们属于类，类对象最终还是要被new出来的。
局部变量的基本数据类型和引用存在栈中，应用的对象实体存储在堆中。因为它们属于方法当中的变量，生命周期会随着方法一起结束

内存泄漏的定义

当一个对象已经不需要使用了，本该被回收时，而有另外一个正在使用的对象持有它的引用，从而导致了对象不能被GC回收。

这种导致了本该被回收的对象不能被回收而停留在堆内存中，就产生了内存泄漏。

内存泄漏与内存溢出的区别

内存泄漏（Memory Leak）

进程中某些对象已经没有使用的价值了，但是他们却还可以直接或间接地被引用到GC Root导致无法回收。当内存泄漏过多的时候，再加上应用本身占用的内存，日积月累最终就会导致内存溢出OOM

内存溢出（OOM）

当应用的heap资源超过了Dalvik虚拟机分配的内存就会内存溢出

内存泄漏带来的影响

应用卡顿

泄漏的内存影响了GC的内存分配，过多的内存泄漏会影响应用的执行效率

应用异常（OOM）

过多的内存泄漏，最终会导致 Dalvik可分配的内存越来越少，更加容易出现OOM

Android开发常见的内存泄漏

（1）单例造成的内存泄漏

错误示例

当调用getInstance时，如果传入的context是Activity的context。

只要这个单例没有被释放，那么这个Activity也不会被释放一直到进程退出才会释放。

public class TestUtil {

    private static TestUtil instance;

    private Context context;

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

    public static TestUtil getInstance(Context mContext) {
        if (instance == null) {
            instance = new TestUtil(mContext);
        }
        return instance;
    }
}

解决方案

能使用Application的Context就不要使用Activity的Content，Application的生命周期伴随着整个进程的周期

（2）Handler造成的内存泄漏

错误示例

mHandler是Handler的非静态匿名内部类的实例，所以它持有外部类Activity的引用，我们知道消息队列是在一个Looper线程中不断轮询处理消息，那么当这个Activity退出时消息队列中还有未处理的消息或者正在处理消息，而消息队列中的Message持有mHandler实例的引用，mHandler又持有Activity的引用，所以导致该Activity的内存资源无法及时回收，引发内存泄漏。

private TextView mTextView;
    private Handler mHandler=new Handler(){
        @Override
        public void handleMessage(Message msg) {
            mTextView.setText("");
        }
    };

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        mTextView= (TextView) findViewById(R.id.tv_home);
        initData();
    }

    private void initData() {
        Message msg=Message.obtain();
        mHandler.sendMessage(msg);
    }

解决方案

创建一个静态Handler内部类，然后对Handler持有的对象使用弱引用，这样在回收时也可以回收Handler持有的对象，这样虽然避免了Activity泄漏，不过Looper线程的消息队列中还是可能会有待处理的消息，所以我们在Activity的Destroy时或者Stop时应该移除消息队列中的消息

private TextView mTextView;
    private Handler mHandler=new MyHandler(this);

    private static class MyHandler extends Handler{
        private WeakReference<Context> reference;

        public MyHandler(Context context) {
            reference=new WeakReference<>(context);
        }

        @Override
        public void handleMessage(Message msg) {
            TestActivity testActivity= (TestActivity) reference.get();
            if (testActivity!=null){
                testActivity.mTextView.setText("");
            }
        }
    }

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        mTextView= (TextView) findViewById(R.id.tv_home);
        initData();
    }

    private void initData() {
        Message msg=Message.obtain();
        mHandler.sendMessage(msg);
    }

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

（3）线程造成的内存泄漏

错误示例

异步任务和Runnable都是一个匿名内部类，因此它们对当前Activity都有一个隐式引用。如果Activity在销毁之前，任务还未完成，那么将导致Activity的内存资源无法回收，造成内存泄漏

new AsyncTask<Void,Void,Void>(){

            @Override
            protected Void doInBackground(Void... params) {
                try {
                    Thread.sleep(10000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                return null;
            }
        }.execute();


        new Thread(new Runnable(){

            @Override
            public void run() {
                try {
                    Thread.sleep(10000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();

解决方案

使用静态内部类，避免了Activity的内存资源泄漏，当然在Activity销毁时候也应该取消相应的任务AsyncTask.cancel()，避免任务在后台执行浪费资源

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

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

        @Override
        protected Void doInBackground(Void... params) {
            try {
                Thread.sleep(10000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return null;
        }

        @Override
        protected void onPostExecute(Void aVoid) {
            super.onPostExecute(aVoid);
            TestActivity testActivity= (TestActivity) reference.get();
            if (testActivity!=null){
                testActivity.mTextView.setText("");
            }
        }
    }

    static class MyRunnable implements Runnable{
        @Override
        public void run() {
            try {
                Thread.sleep(10000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

        /**
         * 执行
         */
        new MyAsyncTask(this).execute();
        new Thread(new MyRunnable()).start();

（4）资源未关闭造成的内存泄漏

错误示例

对于使用了BraodcastReceiver，ContentObserver，File，Cursor，Stream，Bitmap等资源的使用，应该在Activity销毁时及时关闭或者注销，否则这些资源将不会被回收，造成内存泄漏

解决方案

在Activity销毁时及时关闭或者注销

（5）使用了静态的Context(View持有Activity的引用)

private static Drawable mDrawable;

    private ImageView iv;

    private void setWidget() {
        iv=new ImageView(this);
        mDrawable= ContextCompat.getDrawable(this,R.drawable.ad);
        iv.setImageDrawable(mDrawable);
    }

分析一下，有一个静态的Drawable对象，当我给ImageView设置这个Drawable时，ImageView像上面那个例子一样，保存了这个mDrawable的引用，然而ImageView传入了this，也就是ImageView同样持有一个MainActivity的mContext。因为被static修饰的mDrawable是常驻内存的，MainActivity是它的间接引用，所以当MainActivity被销毁时，也不能被GC掉，所以也造成了内存泄漏。

解决方案

应该及时将静态的应用置为null，而且一般不建议将View及Activity设置为静态，在View中不要持有静态资源，静态资源不要持有Activity的Context，用Application的Context代替

（6）注册了系统的服务，但onDestory未注销

错误示例

private SensorManager sensorManager;

    private void setListener() {
        sensorManager= (SensorManager) getSystemService(Context.SENSOR_SERVICE);
        Sensor sensor=sensorManager.getDefaultSensor(Sensor.TYPE_LIGHT);
        sensorManager.registerListener(sensorEventListener,sensor,SensorManager.SENSOR_DELAY_NORMAL);


    }

    //sensorEventListener监听传感器发出的信号
    private SensorEventListener sensorEventListener=new SensorEventListener() {
        //传感器的数值发生变化时调用此方法
        @Override
        public void onSensorChanged(SensorEvent sensorEvent) {
            //values数组中第一个下标的值就是当前的光照强度
            float value=sensorEvent.values[0];
            mTextView.setText("Current light level is "+value+" lx");
        }

        //传感器的精度发生变化时调用此方法
        @Override
        public void onAccuracyChanged(Sensor sensor, int i) {

        }
    };

解决方案

//不需要用的时候记得移除监听
@Override
    protected void onDestroy() {
        super.onDestroy();
        if(sensorManager!=null){
            sensorManager.unregisterListener(sensorEventListener);
        }
    }

（7）不需要用的监听未移除会发生内存泄露

错误示例

mTextView.getViewTreeObserver().addOnGlobalLayoutListener(new ViewTreeObserver.OnGlobalLayoutListener() {
            @Override
            public void onGlobalLayout() {
                //监听布局完成，获取宽高
            }
        });

解决方案

mTextView.getViewTreeObserver().addOnGlobalLayoutListener(new ViewTreeObserver.OnGlobalLayoutListener() {
            @Override
            public void onGlobalLayout() {
                //监听布局完成，获取宽高

                //计算完成，要移除监听
                mTextView.getViewTreeObserver().removeOnGlobalLayoutListener(this);
            }
        });

（8）内部类

非静态内部类持有外部类的一个引用。因此，如果我们在一个外部类中定义一个静态变量，这个静态变量是引用内部类对象。将会导致内存泄漏！因为这相当于间接导致静态引用外部类。

static InnerClass innerClass;


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

    class InnerClass{

    }

Android性能优化-内存泄漏的几个案例

JVM内存管理

1. 静态的

2.栈式的

3.堆式的

内存泄漏的定义

内存泄漏与内存溢出的区别

内存泄漏带来的影响

Android开发常见的内存泄漏

（1）单例造成的内存泄漏

（2）Handler造成的内存泄漏

（3）线程造成的内存泄漏

（4）资源未关闭造成的内存泄漏

（5）使用了静态的Context(View持有Activity的引用)

（6）注册了系统的服务，但onDestory未注销

（7）不需要用的监听未移除会发生内存泄露

（8）内部类

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读