AsyncTask是Android提供的一个执行异步工作的类，内部其实是运用了线程池和Handler来进行异步任务的执行和与主线程的交互。AsyncTask只是一个辅助类，适合执行时间短的异步任务。

本文基于Android7.0的代码来说的。

原文地址 http://blog.csdn.net/qq_25806863/article/details/72782050

示例

AsyncTask的使用方法是很简单的。就做一个简单的进度条。

布局是这样的：

这里写图片描述

里面有一个进度条ProgressBar pb1,开始按钮Button btn1，停止按钮Button stop1

然后实现一个AsyncTask，通过构造方法接收一个ProgressBar和Button进行操作：

public class MyAsyncTask extends AsyncTask<String, Integer, String> {
    private String TAG = this.getClass().getSimpleName();

    Button btn;
    ProgressBar pb;

    public MyAsyncTask(Button btn, ProgressBar pb) {
        this.btn = btn;
        this.pb = pb;
    }

    @Override
    protected String doInBackground(String... params) {
        String result = "完成";
        for (int i = 1; i <= 10; i++) {
            try {
                Log.i(TAG, "doInBackground: "+i);
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            publishProgress(i);
        }

        return result;
    }

    @Override
    protected void onPreExecute() {
        Log.i(TAG, "onPreExecute: 准备工作");
    }

    @Override
    protected void onPostExecute(String s) {
        btn.setText(s);
        Log.i(TAG, "onPostExecute: 回调");
    }

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

然后给两个按钮添加点击事件：

MyAsyncTask task1

task1 = new MyAsyncTask(btn1, pb1);

btn1.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View v) {
        Log.i(TAG, "onClick: 开始1");
        task1.execute();
    }
});

stop1.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View v) {
        Log.i(TAG, "onClick: 停止1");
        task1.cancel(true);
    }
});

这里写图片描述

1.构造参数

AsyncTask定义了三个泛型参数，在继承的时候必须填写。例如上面的AsyncTask<String, Integer, String>

在源码中定义是：

这里写图片描述

参数含义在下面的方法中会具体用到，先大致了解一下：

Params 启动任务的时候输入的参数类型，一般都是String类型，如填个网址啥的。上面示例中就是String类型。
Progress 用来更新进度的类型。表示任务执行的进度的类型。示例用的进度条，所以选择Integer类型。
Result 后台任务执行完后返回的结果，示例中返回的也是String类型。

2.重写方法

要使用AsyncTask最少需要重写方法doInBackground。因为只有这个方法是抽象方法。

这里写图片描述

这个方法是在后台线程执行的。可以看到使用的参数类型Params就是在构造时定义的第一个类型。而返回的类型Result就是定义的第三个类型。

初次之外一般为了对任务流程进行控制还会重写下面几个方法onPreExecute,onPostExecute,onProgressUpdate。

下面几个方法在AsyncTask中是空的,而且都要求在主线程中执行。

@MainThread
protected void onPreExecute() {
}

@MainThread
protected void onPostExecute(Result result) {
}

@MainThread
protected void onProgressUpdate(Progress... values) {
}

onPreExecute() 在异步任务开始前做的操作，
onPostExecute(Result result) 后台任务执行完后，通过这个方法能拿到任务返回的结果，进行处理。
onProgressUpdate(Progress… values) 这个表示进度变化，参数类型是构造时的第二个类型Progress。进度应该是随着任务的执行实时更新的，但是这个方法要在主线程中运行，而doInBackground是在子线程中运行，所以不能直接在doInBackground中调用onProgressUpdate方法，而是通过调用publishProgress(Progress... values)来间接调用这个方法。

3.开始任务

AsyncTask的开始有下面三种方法：

execute(Params... params)
executeOnExecutor(Executor exec,Params... params) 
execute(Runnable runnable)

execute(Params… params) 这个就是在示例中使用的开始任务的方式，传入指定的参数，参数类型要和构造时定义的第一个参数类型Params一样。参数可以为空的，那么在方法doInBackground(Params... params)中的参数也是空的。使用默认的线程池执行任务，会按流程执行onPreExecute,doInBackground(Params... params),onPostExecute(Result result)等方法。
executeOnExecutor(Executor exec,Params… params) 如果默认的线程池不能满足你的要求，可以用这个方法用指定线程池来执行任务。流程跟上面是一样的。
execute(Runnable runnable) 这个方法传进来的是一个Runnable类型，方法中只有一行代码sDefaultExecutor.execute(runnable)就是用默认的线程池直接执行任务，就是使用线程池了，跟前面那些重写的方法没关系。

4.停止任务

要停止任务可以调用下面的方法：

public final boolean cancel(boolean mayInterruptIfRunning) {
    mCancelled.set(true);
    return mFuture.cancel(mayInterruptIfRunning);
}

下面是停止的演示：

这里写图片描述

取消也有一个回调方法可以重写,这里加上，也是运行在主线程中：

@Override
protected void onCancelled() {
    Log.i(TAG, "onCancelled: 取消任务");
    btn.setText("取消了");
}

取消的问题

当cancel方法被调用后，onPostExecute和onProgressUpdate方法都不会再调用了。而doInBackground方法却会一直执行下去，也就是后台任务会继续执行。

cancel(boolean mayInterruptIfRunning)这个参数mayInterruptIfRunning文档中表示是否应该立即终止doInBackground中的任务。

然而实际用起来就不是那样的了，无论我们传的是true还是false，而AsyncTask的cancle方法只是打上了一个取消的标记。并不是直接终止任务。如果是true，则会调用一下后台线程的interrupt方法。

当调用了cancle方法后，调用isCancelled方法会返回true。在doInBackground中应该调用isCancelled来检查当前任务是否被取消，以便及时终止任务。

AsyncTask设计成这样就是为了方便更新主线程界面的，所以对用户来说，在调用了cancle方法后，后台的任务就不会在影响到主线程的界面变化了，因为后续的跟主线程交互的方法都不会再执行了。，也可以说是取消了。

而真的要及时取消doInBackground的继续运行则需要在这个方法中进行一些判断。

不做处理

不做处理也就是在doInBackground中不做判断，像下面这样。看一下输出的日志。当然界面的进度条都会停住，只要看doInBackground有没有在点击停止按钮后停下来。

protected String doInBackground(String... params) {
        String result = "完成";
        for (int i = 1; i <= 10; i++) {
            try {
                Log.i(TAG, "doInBackground: "+i);
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            publishProgress(i);
        }
        return result;
    }

cancle(true):

这里写图片描述

cancle(false):

这里写图片描述

可以看到区别是，当值为true的时候，后台线程也会跑完。但是会调用子线程的interrupt方法，而这个现在正在sleep，所以会引发InterruptedException.

而值为false的时候，没有任何变化，后台线程继续跑完。

做处理

1. 判断isCancelled

在不同的运行节点判断这个方法的值：

@Override
protected String doInBackground(String... params) {
    String result = "完成";
    for (int i = 1; i <= 10; i++) {
        try {
            if (isCancelled()){
                Log.i(TAG, "doInBackground: 被标记停止了");
                break;
            }
            Log.i(TAG, "doInBackground: "+i);
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        publishProgress(i);
    }
    return result;
}

这时调用cancle(false)：

这里写图片描述

调用cancle(true)只是会多打印一个异常，一样会停止。

2.抓异常

因为调用cancle(true)的时候有可能会抛出异常，如这个例子中的InterruptedException，因此可以通过异常捕捉来实现。

@Override
protected String doInBackground(String... params) {
    String result = "完成";
    for (int i = 1; i <= 10; i++) {
        try {
            Log.i(TAG, "doInBackground: "+i);
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
            Log.i(TAG, "doInBackground: 捕捉到异常,退出");
            break;
        }
        publishProgress(i);
    }
    return result;
}

这时调用cancle(true)：

这里写图片描述

并行和串行

据说AsyncTask的任务是并行还是串行执行在不同Android版本有所变化，但是从API13开始，AsyncTask的任务执行都是串行的。

何为串行，比如有下面的界面：

这里写图片描述

有两个task

private ProgressBar pb1;
private ProgressBar pb2;
private Button btn1;
private Button btn2;
private Button stop1;
private Button stop2;
private MyAsyncTask task1, task2;
@Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        initView();
        task1 = new MyAsyncTask(btn1, pb1);
        task2 = new MyAsyncTask(btn2, pb2);java
        btn1.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Log.i(TAG, "onClick: 开始1");
                task1.execute();
            }
        });
        btn2.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Log.i(TAG, "onClick: 开始2");
                task2.execute();
            }
        });
        stop1.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Log.i(TAG, "onClick: 停止1 ");
                task1.cancel(true);
            }
        });
        stop2.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Log.i(TAG, "onClick: 停止2");
                task2.cancel(false);
            }
        });
    }

在上面的MyAstncTask中，后台任务要执行10秒。

这里为了区分，打印开始按钮的名字来区分：

public class MyAsyncTask extends AsyncTask<String, Integer, String> {
    private String TAG = this.getClass().getSimpleName();

    Button btn;
    ProgressBar pb;
    String name;
    public MyAsyncTask(Button btn, ProgressBar pb) {
        this.btn = btn;
        this.pb = pb;
        name = btn.getText().toString();
    }

    @Override
    protected String doInBackground(String... params) {
        String result = "完成";
        for (int i = 1; i <= 10; i++) {
            try {
                Log.i(TAG, "doInBackground: "+name+" "+i);
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
                Log.i(TAG, "doInBackground: 捕捉到异常,退出");
                break;
            }
            publishProgress(i);
        }

        return result;
    }

    @Override
    protected void onPreExecute() {
        Log.i(TAG, "onPreExecute: 准备工作 "+name);
    }

    @Override
    protected void onPostExecute(String s) {
        btn.setText(s);
        Log.i(TAG, "onPostExecute: 回调 "+name);
    }

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


    @Override
    protected void onCancelled() {
        Log.i(TAG, "onCancelled: 取消任务 "+name);
        btn.setText("取消了");
    }
}

在点击第一个开始按钮之后点击第二个开始按钮，效果：

这里写图片描述

打印日志:

这里写图片描述

虽然点击了开始2，但是依然等第一个任务完成了才开始第二个任务。

想要让任务并行执行怎么办呢？其实他之所以会串行执行任务，是因为内部默认的线程池中将任务进行了排队，保证他们一个一个来。只要我们换个满足要求的线程池来执行任务就行了。AstncTask内部就有一个线程池AsyncTask.THREAD_POOL_EXECUTOR可以使用。当然，用Executors来创建也行。

然后将开始任务的execute(Params... params)方法改为executeOnExecutor(Executor exec,Params... params).这里用AsyncTask.THREAD_POOL_EXECUTOR.

task1.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
task2.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);

效果：

这里写图片描述

日志：

这里写图片描述

屏幕横竖屏切换

使用AsyncTask的时候，在屏幕切换也会出现问题。

画面是这样的：

这里写图片描述

日志是这样的，动图中也能看见：

这里写图片描述

虽然屏幕切换后，任务也在执行，也在不停地调用更新进度条的方法，最后也执行了onPostExecute方法，但是界面上就是什么变化都没有。

因为在横竖屏切换的时候，Activity会销毁重建，所以AsyncTask所持有的引用就不是新建的Activity的控件了，新的Activity就不会变化了。

其中一种解决方法

很简单,加上这句就行了。

这里写图片描述

这时屏幕怎么切换都没事

这里写图片描述

Android多线程-AsyncTask的使用和问题(取消，并行和串行，屏幕切换)

示例

1.构造参数

2.重写方法

3.开始任务

4.停止任务

取消的问题

不做处理

做处理

1. 判断isCancelled

2.抓异常

并行和串行

屏幕横竖屏切换

其中一种解决方法

猜你喜欢