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进行操作:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
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]);
}
}

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

1
MyAsyncTask task1
1
task1 = new MyAsyncTask(btn1, pb1);
1
2
3
4
5
6
7
btn1.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
Log.i(TAG, "onClick: 开始1");
task1.execute();
}
});
1
2
3
4
5
6
7
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中是空的,而且都要求在主线程中执行。

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

3.开始任务

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

1
2
3
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.停止任务

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

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

下面是停止的演示:

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

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

取消的问题

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

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

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

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

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

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

不做处理

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

1
2
3
4
5
6
7
8
9
10
11
12
13
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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
@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,因此可以通过异常捕捉来实现。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
@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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
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秒。

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
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.

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

效果:

日志:

屏幕横竖屏切换

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

画面是这样的:

日志是这样的,动图中也能看见:

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

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

其中一种解决方法

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

这时屏幕怎么切换都没事