程序博客网 > mac苹果铃声制作

Android异步任务AsyncTask的使用与原理分析

来源：互联网 发布：mac苹果铃声制作 编辑：程序博客网 时间：2024/04/30 04:15
在上一篇文章《Android缓存机制&一个缓存框架推荐》中说到，在了解了Android缓存机制后我准备自己动手写一个LruCache和DiskLruCache二级缓存的轻量级的图片请求框架，在思考如何搭建这个框架时，纠结于用何种方式去下载图片，是直接new出一个线程呢，还是用看起来稍微高大上档次一点的AsyncTask异步任务来处理？思来想去，还是虚荣心作怪，还是用AsyncTask吧，正好这个工具类我之前用的也比较少，对它的原理也不是很清楚，趁这个机会，好好学一下AsyncTask的使用，并分析一下其源码实现。待分析完AsyncTask之后，接着完成图片请求框架的编写。

1、AsyncTask的使用

    分析AsyncTask原理之前，还是好好学习一下它的具体使用方法。

1.1 AsyncTask简介

    在Android中，我们更新UI的操作必须要在主线程（UI线程）中进行，而下载图片、文件这种操作必须要在子线程中进行，Android为我们提供了Handler机制，实现了子线程与主线程之间的通信。通常做法就是先new出一个子线程Thread，在子线程中完成下载操作后，通过handler发送一条Message给主线程，主线程收到消息后，就可以进行UI的更新工作了，如下：
Handler mHadler = new Handler(){
    @Override
    public void handleMessage(Message msg) {
        super.handleMessage(msg);
        if(msg.what == 1){
            Bitmap bitmap = (Bitmap) msg.obj;
            //更新UI...
        }
    }
};

private void download(){
    new Thread(new Runnable() {
        @Override
        public void run() {
            // 这里进行下载操作...获得了图片的bitmap
            //下载完后才，向主线程发送Message
            Message msg = Message.obtain();
            msg.obj = bitmap;
            msg.what = 1;//区分哪一个线程发送的消息
            mHadler.sendMessage(msg);
        }
    }).start();
}
可以看到，每次要进行下载工作，我们就得先创建出Thread，然后在主线程中写好handler，为了对这个过程进行封装，Android提供了AsyncTask异步任务，AsyncTask对线程和handler进行了封装，使得我们可以直接在AsyncTask中进行UI的更新操作，就好像是在子线程进行UI更新一样。

1.2 创建AsyncTask子类

    AsyncTask是一个抽象类，我们必须写一个子类继承它，在子类中完成具体的业务下载操作。为了对各种情况更好的封装，AsyncTask抽象类指定了三个泛型参数类型，如下：
public abstract class AsyncTask<Params, Progress, Result>{ ... }
其中，三个泛型类型参数的含义如下：
Params：开始异步任务执行时传入的参数类型，即doInBackground()方法中的参数类型；
Progress：异步任务执行过程中，返回下载进度值的类型，即在doInBackground中调用publishProgress()时传入的参数类型；
Result：异步任务执行完成后，返回的结果类型，即doInBackground()方法的返回值类型；

有了这三个参数类型之后，也就控制了这个AsyncTask子类各个阶段的返回类型，如果有不同业务，我们就需要再另写一个AsyncTask的子类进行处理。

1.3 AsyncTask的回调方法

前面我们说过，AsyncTask对线程和handler进行了封装，那它的封装性体现在哪里呢？其实，AsyncTask的几个回调方法正是这种封装性的体现，使得我们感觉在子线程进行UI更新一样。一个基本的AsyncTask有如下几个回调方法：
（1）onPreExecute()：在执行后台下载操作之前调用，运行在主线程中；
（2）doInBackground()：核心方法，执行后台下载操作的方法，必须实现的一个方法，运行在子线程中；
（3）onPostExecute()：后台下载操作完成后调用，运行在主线程中；

因此，AsyncTask的基本生命周期过程为：onPreExecute() --> doInBackground() --> onPostExecute()。其中，onPreExecute() 和onPostExecute()分别在下载操作前和下载操作后调用，同时它们是在主线程中进行调用，因此可以在这两个方法中进行UI的更新操作，比如，在onPreExecute()方法中，将下载等待动画显示出来，在onPostExecute()方法中，将下载等待动画进行隐藏。

如果我们想向用户展示文件的下载进度情况，这时，我们可以在doInBackground()下载操作中，调用publishProgress()，将当前进度值传入该方法，而publishProgress()内部会去调用AsyncTask的另一个回调方法：
（4）onProgressUpdate()：在下载操作doInBackground()中调用publishProgress()时的回调方法，用于更新下载进度，运行在主线程中；

因此，在需要更新进度值时，AsyncTask的基本生命周期过程为：onPreExecute() --> doInBackground() --> publishProgress() --> onProgressUpdate() --> onPostExecute()。
可以看到，AsyncTask的优秀之处在于几个回调方法的设置上，只有donInBackground()是运行在子线程的，其他三个回调方法都是在主线程中运行，因此，只要在AsyncTask中，就可以实现文件的后台下载、UI的更新操作。

好了，明白了如何创建一个AsyncTask，以及AsyncTask的几个回调方法的调用时机，我们就可以来实战体验一下。在例子中，我们去下载一张图片，并通过进度条显示下载的进度。
首先实现一个AsyncTask的具体实现类，进行图片的下载，如下：
public class MyAsyncTask extends AsyncTask<String, Integer, Bitmap>{
    private ProgressBar mPreogressBar;//进度条
    private ImageView mImageView;//图片显示控件

    public MyAsyncTask(ProgressBar pb,ImageView iv){
        mPreogressBar = pb;
        mImageView = iv;
    }

    @Override
    protected void onPreExecute() {
        super.onPreExecute();
        mPreogressBar.setVisibility(View.VISIBLE);
    }

    @Override
    protected Bitmap doInBackground(String... params) {
        String urlParams = params[0];//拿到execute()传过来的图片url
        Bitmap bitmap = null;
        URLConnection conn = null;
        InputStream is = null;
        try {
            URL url = new URL(urlParams);
            conn = url.openConnection();
            is = conn.getInputStream();

            //这里只是为了演示更新进度的功能，实际的进度值需要在从输入流中读取时逐步获取
            for(int i = 0; i < 100; i++){
                publishProgress(i);
                Thread.sleep(50);//为了看清效果，睡眠一段时间
            }
            //将获取到的输入流转成Bitmap
            BufferedInputStream bis = new BufferedInputStream(is);
            bitmap = BitmapFactory.decodeStream(bis);

            is.close();
            bis.close();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return bitmap;
    }

    @Override
    protected void onProgressUpdate(Integer... values) {
        super.onProgressUpdate(values);
        mPreogressBar.setProgress(values[0]);
    }

    @Override
    protected void onPostExecute(Bitmap bitmap) {
        super.onPostExecute(bitmap);
        mPreogressBar.setVisibility(View.GONE);
        mImageView.setImageBitmap(bitmap);
    }
}
上面doInBackground()中获取进度值时，我们只是为了做一个进度值更新调用的演示，实际项目文件下载中，我们可能会对拿到的输入流进行处理，比如读取输入流将文件保存到本地，在读取输入流的时候，我们就可以获取到已经读取的输入流大小作为进度值了，如下：            
//实际项目中如何获取文件大小作为进度值及更新进度值            int totalSize = conn.getContentLength();//获取文件总大小            int size = 0;//保存当前下载文件的大小，作为进度值            int count = 0;            byte[] buffer = new byte[1024];            while((count = is.read(buffer)) != -1){                size += count;//获取已下载的文件大小                //调用publishProgress更新进度，它内部会回调onProgressUpdate()方法                publishProgress(size,totalSize);                Thread.sleep(100);//为了看清效果，睡眠一段时间            }
在MainActivity中使用：
public class MainActivity extends AppCompatActivity {
    private ImageView mImageView;
    private ProgressBar mProgressBar;
    private static String URL = "http://c.hiphotos.baidu.com/baike/s%3D220/sign=86442af5a6c27d1ea1263cc62bd4adaf/42a98226cffc1e17d8f914604890f603738de919.jpg";
    private MyAsyncTask asyncTask;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.image);

        mImageView = (ImageView) findViewById(R.id.id_image);
        mProgressBar = (ProgressBar) findViewById(R.id.pb);

        asyncTask = new MyAsyncTask(mProgressBar, mImageView);
        asyncTask.execute(URL);//将图片url作为参数传入到doInBackground()中
    }
}
布局文件如下：
<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:padding="16dp"
    android:layout_width="match_parent"
    android:layout_height="match_parent">
    <ImageView
        android:id="@+id/id_image"
        android:layout_width="match_parent"
        android:layout_height="match_parent" />
    <ProgressBar
        android:id="@+id/pb"
        style="@style/Widget.AppCompat.ProgressBar.Horizontal"
        android:layout_centerInParent="true"
        android:layout_width="match_parent"
        android:layout_height="30dp" />
</RelativeLayout>
效果如下：


由于需要联网，注意在AndroidManifest.xml中加入网络访问权限。

1.4 取消下载任务   

我们先来看两个现象。 我们在布局中加一个按钮，点击这个按钮再加载一次图片，布局如下：    
<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:padding="16dp"
    android:layout_width="match_parent"
    android:layout_height="match_parent">
    <ImageView
        android:id="@+id/id_image"
        android:layout_width="match_parent"
        android:layout_height="match_parent" />
    <ProgressBar
        android:id="@+id/pb"
        style="@style/Widget.AppCompat.ProgressBar.Horizontal"
        android:layout_centerInParent="true"
        android:layout_width="match_parent"
        android:layout_height="30dp" />
    <Button
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:padding="15dp"
        android:id="@+id/id_btn"
        android:text="加载图片"
        android:textSize="16sp"
        android:layout_alignParentBottom="true"
        android:onClick="loadImage"/>
</RelativeLayout>
因此，在MainActivity中，我们就需要加入loadImage方法，如下：
public class MainActivity extends AppCompatActivity {
    private ImageView mImageView;
    private ProgressBar mProgressBar;
    private static String url = "http://c.hiphotos.baidu.com/baike/s%3D220/sign=86442af5a6c27d1ea1263cc62bd4adaf/42a98226cffc1e17d8f914604890f603738de919.jpg";
    private MyAsyncTask asyncTask;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.image);

        mImageView = (ImageView) findViewById(R.id.id_image);
        mProgressBar = (ProgressBar) findViewById(R.id.pb);

        asyncTask = new MyAsyncTask(mProgressBar, mImageView);
        asyncTask.execute(url);
}

    public void loadImage(View v){
        asyncTask.execute(url);
    }
}
现象一：在loadImage()方法中，我们直接再次通过asyncTask.execute()执行加载。看看此时效果如何：

onCreate中初始加载完一次图片后，我们点击“加载图片”按钮，此时程序直接崩溃了！这是因为，每一个new出的AsyncTask只能执行一次execute()，如果同一个AsyncTask多次执行execute()执行将会报错。
现象二：我们来修改loadImage()方法，在该方法中，我们在打开自身MainActivity，使得多次初始化的时候进行加载，如下：
public void loadImage(View v){
    Intent i = new Intent(this,MainActivity.class);
    startActivity(i);
}
此时效果如下：

在第一次运行程序进入MainActivity，执行execute但在显示出图片之前，立即点击“加载图片”按钮，新打开一个MainActivity，我们发现这个MainActivity的进度条没有立即展示出进度出来，说明这个MainActivity的AsyncTask没有立即执行doInBackground()，这是因为AsyncTask内部使用的是线程池，相当于里面有一个线程队列，执行一次execute时会将一个下载任务加入到线程队列，只有前一个任务完成了，下一个下载任务才会开始执行。
为了达到我们想要的效果，我们自然想到把上一个任务给取消掉。的确，AsyncTask为我们提供了cancel()方法来取消一个任务的执行，但是要注意的是，cancel方法并没有能力真正去取消一个任务，其实只是设置这个任务的状态为取消状态，我们需要在doInBackground()下载中进行检测，一旦检测到该任务被用户取消了，立即停止doInBackground()方法的执行。
我们先修改MainActivity，根据不同业务需求，在不同地方进行任务的取消，我们这里在onPause()中进行任务的取消，在MainActivity方法中加入onPause()方法，如下：
@Override
protected void onPause() {
    super.onPause();
    if(asyncTask != null && asyncTask.getStatus() == AsyncTask.Status.RUNNING){
        //cancel只是将对应的任务标记为取消状态
        asyncTask.cancel(true);
    }
}
继续修改AsyncTask，在这里面进行任务是否被取消的检测，这里我们只简单修改下doInBackground()和onProgressUpdae()方法，实际项目中开自己的业务逻辑来控制，如下：
@Override
protected Bitmap doInBackground(String... params) {
    String urlParams = params[0];//拿到execute()传过来的图片url
    Bitmap bitmap = null;
    URLConnection conn = null;
    InputStream is = null;
    try {
        URL url = new URL(urlParams);
        conn = url.openConnection();
        is = conn.getInputStream();

        for(int i = 0; i < 100; i++){
            if(isCancelled()){//通过isCancelled()判断任务任务是否被取消
                break;
            }
            publishProgress(i);
            Thread.sleep(50);//为了看清效果，睡眠一段时间
        }
        BufferedInputStream bis = new BufferedInputStream(is);
        bitmap = BitmapFactory.decodeStream(bis);

        is.close();
        bis.close();
    } catch (IOException e) {
        e.printStackTrace();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    return bitmap;
}

@Override
protected void onProgressUpdate(Integer... values) {
    super.onProgressUpdate(values);
    if(isCancelled()){//通过isCancelled()判断任务任务是否被取消
        return;
    }
    mPreogressBar.setProgress(values[0]);
}
在doInBackground()的for循环更新进度过程中，我们持续不断的监听任务十分被取消，一旦取消了，尽快退出doInBackground的执行，现在运行效果如下：

可以看到，现在每次点击“加载图片”按钮，新的界面都会立即更新进度条，我们就业把前面的任务给取消掉了。

使用小结：
（1）AsyncTask中，只有doInBackground()方法是处于子线程中运行的，其他三个回调onPreExecute()、onPostExecute()、onProgressUpdate()都是在UI线程中进行，因此在这三个方法里面可以进行UI的更新工作；
（2）每一个new出的AsyncTask只能执行一次execute()方法，多次运行将会报错，如需多次，需要新new一个AsyncTask；
（3）AsyncTask必须在UI线程中创建实例，execute()方法也必须在UI线程中调用；

2、AsyncTask内部实现原理

进入AsyncTask源码，简单分析一下AsyncTask的内部实现。前面说到，AsyncTask内部封装了异步任务队列和Handler，那我们就从这两块入手。

2.1 AsyncTask的内部异步队列  

在我们上面那个例子中，讲到第二个现象时，就可以直观的看到，AsyncTask的内部肯定是基于工作队列这种方式的，每次执行execute()就会把当前的任务加入到工作队列中。但是大家有没有发现这么个问题，我每次点击“加载图片”按钮，都会进入MainActivity的onCreate方法中去新建一个AsyncTask的对象，既然对象都是新的了，为什么AsyncTask中的工作队列还是能够正常管理呢？这就说明，AsyncTask内部的线程池、工作队列的定义都应该是static的，而static定义的变量是属于进程范围内的，只有这样，这些static的变量才能交给AsyncTask这个类来管理，而不是AsyncTask的具体子类对象。如下部分变量声明：    
private static final ThreadFactory sThreadFactory = new ThreadFactory() {        private final AtomicInteger mCount = new AtomicInteger(1);        public Thread newThread(Runnable r) {            return new Thread(r, "AsyncTask #" + mCount.getAndIncrement());        }    };    private static final BlockingQueue<Runnable> sPoolWorkQueue =            new LinkedBlockingQueue<Runnable>(128);    /**     * 真正用来执行任务的的线程池     */    public static final Executor THREAD_POOL_EXECUTOR            = new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE,                    TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory);    /**     * 定义一个线程池，在线程池中有一个Runnable任务队列，用来存放、顺序执行任务     */    public static final Executor SERIAL_EXECUTOR = new SerialExecutor();    //AsyncTask内部默认使用的线程池    private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;    //自定义的一个Handler    private static InternalHandler sHandler;
可以看到，优线程池有关的都定义为了static类型，其中，SERIAL_EXECUTOR内部就定义了一个任务队列ArrayDeque<Runnable> mTasks，当我们调用AsyncTask的execute()时，就会将当前任务加入到该队列中。先来看执行AsyncTask的execute()时的情景：
@MainThread
public final AsyncTask<Params, Progress, Result> execute(Params... params) {
    return executeOnExecutor(sDefaultExecutor, params);
}
AsyncTask的execute()交给了executeOnExecutor()方法，将将默认的线程池作为参数传进来，进入executeOnExecutor方法中：
@MainThread
public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,
        Params... params) {
    if (mStatus != Status.PENDING) {//1、这里判断当前AsyncTask是否正在执行或已执行完毕
        switch (mStatus) {
            case RUNNING:
                throw new IllegalStateException("Cannot execute task:"
                        + " the task is already running.");
            case FINISHED:
                throw new IllegalStateException("Cannot execute task:"
                        + " the task has already been executed "
                        + "(a task can be executed only once)");
        }
    }
    mStatus = Status.RUNNING;//2、设置正在执行的状态
    onPreExecute();//3、回调onPreExecute()方法
    mWorker.mParams = params;
    exec.execute(mFuture);//4、放到前面默认构造的线程池中去执行
    return this;
}
上面第一步，先判断当前AsyncTask是否正在运行或已经执行完毕，如果正在执行或执行完毕再次执行将抛出异常，这也正是我们前面在使用的时候谈到，同一个AsyncTask不能多次进行execute()的原因！到了第三步的时候，先去调用一下onPreExecute()方法，因为executeOnExecutor方法本身就是在UI线程中运行的，所以onPreExecute也会在UI线程中运行。第四步，才会开始讲当前AsyncTask任务加入到队列中，我们进入默认的线程池中去看一下：
private static class SerialExecutor implements Executor {
    final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();
    Runnable mActive;
    public synchronized void execute(final Runnable r) {
        mTasks.offer(new Runnable() {
            public void run() {
                try {
                    r.run();
                } finally {
                    scheduleNext();
                }
            }
        });
        if (mActive == null) {
            scheduleNext();
        }
    }

    protected synchronized void scheduleNext() {
        if ((mActive = mTasks.poll()) != null) {
            THREAD_POOL_EXECUTOR.execute(mActive);
        }
    }
}
在第四步执行execute时，实际就是调用的SerialExecutor中的execute方法，在这里面，先创建了一个Runnable对象，然后将这个Runnable对象添加到任务队列mTasks中，在当执行到这个Runnable时调用scheduleNext去队列中取出一个任务，然后交给另一个线程池去真正执行这个任务。

关于线程池相关知识，可以看一下这篇文章《Java笔试面试题整理第六波》。
   

2.2 与UI线程进行交互-handler

AsyncTask内部通过自定义的static类型的InternalHandler和UI线程进行交互。InternalHandler实现如下：
private static class InternalHandler extends Handler {
    public InternalHandler() {
        super(Looper.getMainLooper());
    }

    @SuppressWarnings({"unchecked", "RawUseOfParameterizedType"})
    @Override
    public void handleMessage(Message msg) {
        AsyncTaskResult<?> result = (AsyncTaskResult<?>) msg.obj;
        switch (msg.what) {
            case MESSAGE_POST_RESULT:
                // There is only one result
                result.mTask.finish(result.mData[0]);
                break;
            case MESSAGE_POST_PROGRESS:
                result.mTask.onProgressUpdate(result.mData);
                break;
        }
    }
}
每当收到子线程发来的和UI线程进行通信的handler请求时，先从Message中拿到子线程发来的结果参数AsyncTaskResult，AsyncTaskResult里面封装了AsyncTask对象和数据信息，如下：
private static class AsyncTaskResult<Data> {
    final AsyncTask mTask;
    final Data[] mData;
    AsyncTaskResult(AsyncTask task, Data... data) {
        mTask = task;
        mData = data;
    }
}
然后根据不同状态调用不同方法，如果是MESSAGE_POST_RESULT状态，就调用AsyncTask的finish()方法，finish方法中会去判断当前任务十分被cancel，如果没有cancel则开始回调onPostExecute()方法；如果状态是MESSAGE_POST_PROGRESS，则回调onProgressUpdate()方法。
当子线程需要和UI线程进行通信时，就会通过这个handler，往UI线程发送消息。需要通过handler来发送消息，肯定是在子线程异步任务的时候才需要，在AsyncTask中需要handler的地方其实就是两个地方，一个是doInBackground()在运行过程中，需要更新进度值的时候；一个是doInBackground()运行完成后，需要回到到UI线程中的onPostExecute()方法的时候。
对于一：我们在doInBackground()中调用publicProgress()进行进度值的更新，因此在publicProgress()中肯定会有handler的身影，如下：
protected final void publishProgress(Progress... values) {
    if (!isCancelled()) {
        getHandler().obtainMessage(MESSAGE_POST_PROGRESS,
                new AsyncTaskResult<Progress>(this, values)).sendToTarget();
    }
}
对于二：其实就是一个异步任务执行完后后的返回处理，而FutureTask正是处理处理Runnable运行返回结果的。
在2.1部分的executeOnExecutor方法中第四步，我们在执行execute(mFuture)，传入了一个mFuture，mFuture是在初始化AsyncTask的时候进行构建的，如下：
mFuture = new FutureTask<Result>(mWorker) {
    @Override
    protected void done() {
        try {
            postResultIfNotInvoked(get());//这里面通过handler往UI线程发送消息
        } catch (InterruptedException e) {
            android.util.Log.w(LOG_TAG, e);
        } catch (ExecutionException e) {
            throw new RuntimeException("An error occurred while executing doInBackground()",
                    e.getCause());
        } catch (CancellationException e) {
            postResultIfNotInvoked(null);
        }
    }
};
在上面的postResultIfNotInvoked()中会通过handler进行消息的发送。

AsyncTask原理总结：
AsyncTask主要是对异步任务和handler的封装，在处理异步任务时，AsyncTask内部使用了两个线程池，一个线程池sDefaultExecutor是用来处理用户提交（执行AsyncTask的execute时）过来的异步任务，这个线程池中有一个Runnable异步任务队列ArrayDeque<Runnable> mTasks ，把提交过来的异步任务放到这个队列中；另一个线程池THREAD_POOL_EXECUTOR，用来真正执行异步任务的。在处理handler时，自定义了一个InternalHandler，在publicProgress()和doInBackground()运行完成后，会通过这个handler往UI线程发送Message。

3、AsyncTask在使用中的一个特殊情况

我们在使用AsyncTask的时候，一般会在onPreExecute()和onPostExecute()中进行UI的更新，比如等待图片的显示、进度条的显示...当我们一个Activity中正在使用AsyncTask进行文件的下载时，如果此时屏幕发生了旋转，Activity会进行re-onCreate，又会创建一个AsyncTask进行文件的下载，这个正是我们前面将取消任务的时候谈到的第二个现象，我们只需要在onPause()中进行取消cancel()即可。但是这样仅仅是解决了发生等待的情况，因为Activity再次进入了onCreate()方法，还是会进行文件的下载，为了解决这个问题，一种方案是通过判断onCreate(Bundle savedInstanceState)方法参数中的savedInstanceState==null？来判断是哪种情况，只有savedInstanceState==null时才去创建新的AsyncTask。

4、AsyncTask和Handler的比较

AsyncTask：
    优点：AsyncTask是一个轻量级的异步任务处理类，轻量级体现在，使用方便、代码简洁上，而且整个异步任务的过程可以通过cancel()进行控制；
    缺点：不适用于处理长时间的异步任务，一般这个异步任务的过程最好控制在几秒以内，如果是长时间的异步任务就需要考虑多线程的控制问题；当处理多个异步任务时，UI更新变得困难。
Handler:
    优点：代码结构清晰，容易处理多个异步任务；
    缺点：当有多个异步任务时，由于要配合Thread或Runnable，代码可能会稍显冗余。

总之，AsyncTask不失为一个非常好用的异步任务处理类，只要不是频繁对大量UI进行更新，可以考虑使用；而Handler在处理大量UI更新时可以考虑使用。

下一篇就要开始图片请求的二级缓存框架的编写了~



11 2
mac苹果铃声制作 mac苹果铃声制作
原创粉丝点击
热门IT博客
mac版炒股软件哪个好mac版炒股软件哪个好
建立淘宝网站的步骤建立淘宝网站的步骤
htct9199软件下载
剑网三源码
java 线程使用
php项目管理
爱尔兰共和军 知乎
java poi视频教程下载
济南市软件行业协会
光子精灵s淘宝
越狱下软件源
讨鬼传极a卡怎么优化
雅思备考资料 知乎
上海阿里招聘java
python 前五分钟
淘宝网薄少女卫衣开衫
商海通牒 知乎
c语言点滴pdf
java电子商城流程
影视大全神器软件
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 专业门禁安装 笔记本安装固态硬盘 家庭影院安装 win10系统安装 电动窗帘安装 工程安装公司 买马桶包安装吗 工业管道安装 电力工程安装 北京宽带安装 台式机安装固态硬盘 下水管道安装 安装消防管道 小区监控安装 安装网络电话 建筑安装工程公司 固定电话安装 风机盘管安装 机电安装工程公司 厨房油烟机安装 压力管道安装公司 安装工程公司 用u盘安装win7系统 电视壁挂安装 上门安装电脑 安装win7旗舰版 化工设备安装公司 灯具安装图集 钢结构安装价格 led吸顶灯安装图解 太阳能板安装 天津监控安装 保鲜冷库安装 小区安装监控 美工招聘 经理助理招聘 咋装 安卓手机系统重装 电脑系统下载到手机 手机系统重装 应用程序

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里