Android —— 静态AsyncTask解决内存泄漏

Android中我们经常需要开启子线程去获取网络数据,或者说做一些耗时操作,开发者经常使用的就是AsyncTask,Android 1.5提供的工具类AsyncTask使我们创建异步线程更加便捷。如果你还没有AsyncTask的基础,那么先阅读一下这篇博文吧。
Android多线程编程(异步通信)—>Handler和AsyncTask

本博文编写的理由:
线程的关闭,可以通过在activity的destroy方法中执行task的cancel方法,通过判断isCancelled值来退出任务,在activity结束的时候就结束了任务。但是相对于其他情况(比如说操作网络的时候),doInBackground方法里面还是会继续执行,直到结束。但是至少,我们使用了cancel方法,最终不会执行onPostExecute,而改去执行onCancelled。
于是相对于不能中断的任务,为避免任务一直持有activity,我们可以通过使用静态内部类,并且使用WeakReference来包裹我们的activity以达到更新UI的目的。

1.线程AsyncTask产生的问题

  • 开启线程后,未结束,此时用户又一次,甚至多次开启线程,导致多次请求。
    解决方式:将线程写为静态static。
  • 当用户开启线程后,退出界面,多次进入。由于线程持有Activity的变量的实例,导致Activity无法被回收,从而导致内存泄漏
    解决方式:采用弱引用的方式,将线程与Activity进行解耦。

2.弱引用的理解

强引用、弱引用经常用来解决OOM的问题。
先来说一下 强引用 吧:
这里写图片描述
注:如果强引用的对象只要不为null,gc就不会回收掉。
弱引用:弱引用是通过WeakReference类实现,使gc可以进行回收。
这里写图片描述

3.将线程静态后的优缺点

前面我们说了可以将线程做成静态的,加上利用弱引用实现线程和Activity的解耦。而静态后随出现了一些问题需要我们考虑:

  • 1)静态类中使用的变量需要静态,有何隐患。
    静态类是一直在内存中存在的,占用一定的内存,所以静态变量和类不能过多,否则会导致内存的不足。
    但必要时也是不可避免的。
  • 2)静态线程的开启方式,以及当线程需要外部传参的实现:
    线程的启动
    利用创建实例的方式:一个AsyncTask实例只能被执行一次;采用此方式那么传参可以直接通过线程的构造函数即可。

例如对于创建的LocalProductAsyncTask线程:开启方式。

refreshTask = new LocalProductAsyncTask(mView, 1, mConfig.mPageSize, classiftDatas, keyWord, false);
                    refreshTask.execute();

传参:
不管线程是静态还是非静态,开启时都需要new 实例,这个时候传参就可以了。

4.具体的实现过程

用静态内部类来防止持有外部类的隐性引用。
实例1:handler弱引用:
这里写图片描述
实例2:附上完整代码:

public class AsyncTaskActivity extends Activity {
    private AsyncTask task;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        /* 用匿名内部类的方式创建*/
         task = new AsyncTask() {
            @Override
            protected Object doInBackground(Object[] params) {
                for(int i=0;i<10;i++){
                    Log.i("task","i="+i);
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    if(isCancelled()){
                        break;
                    }
                }
                return null;
            }

             @Override
             protected void onPostExecute(Object o) {
                 super.onPostExecute(o);
                 Log.i("task","执行结束了");
             }

             @Override
             protected void onCancelled() {
                 super.onCancelled();
                 Log.i("task","执行了取消");
             }
         };
        task.execute();
        //从log可以看到,上个task和下面的task是串行执行的
        new MyTask(this).execute();
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        task.cancel(true);
        //这里不做取消MyTask的任务是为了验证weakReference是否起作用
    }


    public void doSomething(){
        //为保险,还是需要判断下当前activity是否已经销毁,因为weakReference修饰的对象并不是马上就能被回收
        Log.i("AsyncActivity","异步任务完成,更新UI");
    }


    static class MyTask extends AsyncTask<String,Integer,String>{
        private WeakReference<Activity> weakAty;
        public MyTask(Activity activity){
            weakAty = new WeakReference<Activity>(activity);
        }

        @Override
        protected String doInBackground(String... params) {
            for(int i=0;i<100;i++){
                Log.i("Mytask","i="+i);
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                if(isCancelled()){
                    break;
                }
            }
            return null;
        }

        @Override
        protected void onPostExecute(String s) {
            super.onPostExecute(s);
            Log.i("Mytask","执行结束了");
            AsyncTaskActivity mActivity;
            if((mActivity= (AsyncTaskActivity) weakAty.get())!=null){
                mActivity.doSomething();
            }
        }

        @Override
        protected void onCancelled() {
            super.onCancelled();
            Log.i("Mytask","执行了取消");
        }
    }
}
阅读更多
换一批

没有更多推荐了,返回首页