布局文件main.xml代码如下:
<?xml version="1.0" encoding="utf-8"?><LinearLayout xmlns:android=“http://schemas.android.com/apk/res/android”
android:orientation=“vertical”
android:layout_width=“fill_parent”
android:layout_height=“fill_parent”>
<Button
android:id=“@+id/execute”
android:layout_width=“fill_parent”
android:layout_height=“wrap_content”
android:text=“execute”/>
<Button
android:id=“@+id/cancel”
android:layout_width=“fill_parent”
android:layout_height=“wrap_content”
android:enabled=“false”
android:text=“cancel”/>
<ProgressBar
android:id=“@+id/progress_bar”
android:layout_width=“fill_parent”
android:layout_height=“wrap_content”
android:progress=“0”
android:max=“100”
style=“?android:attr/progressBarStyleHorizontal”/>
<ScrollView
android:layout_width=“fill_parent”
android:layout_height=“wrap_content”>
<TextView
android:id=“@+id/text_view”
android:layout_width=“fill_parent”
android:layout_height=“wrap_content”/>
因为需要访问网络,所以我们还需要在AndroidManifest.xml中加入访问网络的权限:
二、 AsyncTask的实现基本原理
===================
上面介绍了AsyncTask的基本应用,有些朋友也许会有疑惑,AsyncTask内部是怎么执行的呢,它执行的过程跟我们使用Handler又有什么区别呢?答案是:AsyncTask是对Thread+Handler良好的封装,在android.os.AsyncTask代码里仍然可以看到Thread和Handler的踪迹。下面就向大家详细介绍一下AsyncTask的执行原理。
源代码如下 :
/**
-
Override this method to perform a computation on a background thread. The
-
specified parameters are the parameters passed to {@link #execute}
-
by the caller of this task.
-
This method can call {@link #publishProgress} to publish updates
-
on the UI thread.
-
@param params The parameters of the task.
-
@return A result, defined by the subclass of this task.
-
这是一个abstract 方法,因此必须覆写。
-
@see #onPreExecute()
-
@see #onPostExecute
-
@see #publishProgress
*/
protected abstract Result doInBackground(Params… params);
/**
-
Runs on the UI thread before {@link #doInBackground}.
-
@see #onPostExecute
-
@see #doInBackground
*/
protected void onPreExecute() {
}
/**
-
Runs on the UI thread after {@link #doInBackground}. The
-
specified result is the value returned by {@link #doInBackground}
-
or null if the task was cancelled or an exception occured.
*后台操作执行完后会调用的方法,在此更新UI。
-
@param result The result of the operation computed by {@link #doInBackground}.
-
@see #onPreExecute
-
@see #doInBackground
*/
@SuppressWarnings({“UnusedDeclaration”})
protected void onPostExecute(Result result) {
}
/**
-
Runs on the UI thread after {@link #publishProgress} is invoked.
-
The specified values are the values passed to {@link #publishProgress}.
-
@param values The values indicating progress.
-
传值更新进度条
-
@see #publishProgress
-
@see #doInBackground
*/
@SuppressWarnings({“UnusedDeclaration”})
protected void onProgressUpdate(Progress… values) {
}
/**
-
Executes the task with the specified parameters. The task returns
-
itself (this) so that the caller can keep a reference to it.
-
This method must be invoked on the UI thread. 注意execute方法必须在UI线程中调用
-
@param params The parameters of the task.
-
@return This instance of AsyncTask.
-
@throws IllegalStateException If {@link #getStatus()} returns either
-
{@link AsyncTask.Status#RUNNING} or {@link AsyncTask.Status#FINISHED}.
*/
public final AsyncTask<Params, Progress, Result> execute(Params… params) {
if (mStatus != Status.PENDING) {
// 状态检测,只有在PENDING状态下才能正常运行,构造抛出异常
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;
// 正在执行任务前的准备处理
onPreExecute();
// 获得从UI现存传递来的参数
mWorker.mParams = params;
// 交给线程池管理器进行调度,参数为FutureTask类型,构造mFuture时mWorker被传递了进去,后边会继续分析
sExecutor.execute(mFuture);
// 返回自身,使得调用者可以保持一个引用
return this;
}
/**
-
This method can be invoked from {@link #doInBackground} to
-
publish updates on the UI thread while the background computation is
-
still running. Each call to this method will trigger the execution of
-
{@link #onProgressUpdate} on the UI thread.
-
@param values The progress values to update the UI with.
-
@see #onProgressUpdate
-
@see #doInBackground
*/
protected final void publishProgress(Progress… values) {
sHandler.obtainMessage(MESSAGE_POST_PROGRESS,
new AsyncTaskResult(this, values)).sendToTarget();
}
我们可以看到关键几个步骤的方法都在其中。
1、 doInBackground(Params… params) 是一个抽象方法,我们继承AsyncTask时必须覆写此方法;
2、 onPreExecute()、onProgressUpdate(Progress… values)、onPostExecute(Result result)、onCancelled() 这几个方法体都是空的,我们需要的时候可以选择性的覆写它们;
3、 publishProgress(Progress… values) 是final修饰的,不能覆写,只能去调用,我们一般会在doInBackground(Params… params)中调用此方法来更新进度条;
**4、**另外,我们可以看到有一个Status的枚举类和getStatus()方法,Status枚举类代码段如下:
//初始状态
private volatile Status mStatus = Status.PENDING;
public enum Status {
/**
- Indicates that the task has not been executed yet.
*/
PENDING,
/**
- Indicates that the task is running.
*/
RUNNING,
/**
- Indicates that {@link AsyncTask#onPostExecute} has finished.
*/
FINISHED,
}
/**
-
Returns the current status of this task.
-
@return The current status.
*/
public final Status getStatus() {
return mStatus;
}
可以看到,AsyncTask的初始状态为 PENDING ,代表待定状态, RUNNING 代表执行状态, FINISHED 代表结束状态,这几种状态在AsyncTask一次生命周期内的很多地方被使用,非常重要。
在execute函数中涉及到三个陌生的变量:mWorker、sExecutor、mFuture,我们也会看一下:
关于sExecutor,它是java.util.concurrent.ThreadPoolExecutor的实例,用于管理线程的执行。代码如下:
private static final int CORE_POOL_SIZE = 5;
private static final int MAXIMUM_POOL_SIZE = 128;
private static final int KEEP_ALIVE = 10;
//新建一个队列用来存放线程
private static final BlockingQueue sWorkQueue =
new LinkedBlockingQueue(10);
//新建一个线程工厂
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 ThreadPoolExecutor sExecutor = new ThreadPoolExecutor(CORE_POOL_SIZE,
MAXIMUM_POOL_SIZE, KEEP_ALIVE, TimeUnit.SECONDS, sWorkQueue, sThreadFactory);
mWorker实际上是AsyncTask的一个的抽象内部类的实现对象实例,它实现了Callable接口中的call()方法,代码如下:
[java] view plaincopy
private static abstract class WorkerRunnable<Params, Result> implements Callable {
Params[] mParams;
}
而mFuture实际上是 java.util.concurrent.FutureTask 的实例,下面是它的FutureTask类的相关信息:
/**
-
A cancellable asynchronous computation.
-
…
*/
public class FutureTask implements RunnableFuture {
public interface RunnableFuture extends Runnable, Future {
/**
-
Sets this Future to the result of its computation
-
unless it has been cancelled.
*/
void run();
}
可以看到FutureTask是一个可以中途取消的用于异步计算的类。
下面是mWorker和mFuture实例在AsyncTask中的体现:
private final WorkerRunnable<Params, Result> mWorker;
private final FutureTask mFuture;
public AsyncTask() {
mWorker = new WorkerRunnable<Params, Result>() {
//call方法被调用后,将设置优先级为后台级别, 然后调用AsyncTask的doInBackground方法
public Result call() throws Exception {
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
return doInBackground(mParams);
}
};
// 在mFuture实例中,将会调用mWorker做后台任务,完成后会调用done方法。
// 这里将mWorker作为参数传递给了mFuture对象
mFuture = new FutureTask(mWorker) {
@Override
protected void done() {
Message message;
Result result = null;
try {
result = get();
} catch (InterruptedException e) {
android.util.Log.w(LOG_TAG, e);
} catch (ExecutionException e) {
throw new RuntimeException(“An error occured while executing doInBackground()”,
e.getCause());
} catch (CancellationException e) {
//发送取消任务的消息
message = sHandler.obtainMessage(MESSAGE_POST_CANCEL,
new AsyncTaskResult(AsyncTask.this, (Result[]) null));
message.sendToTarget();
return;
} catch (Throwable t) {
throw new RuntimeException("An error occured while executing "
- “doInBackground()”, t);
}
//发送显示结果的消息
message = sHandler.obtainMessage(MESSAGE_POST_RESULT,
new AsyncTaskResult(AsyncTask.this, result));
message.sendToTarget();
}
};
}
我们看到上面的代码中,mFuture实例对象的done()方法中,如果捕捉到了CancellationException类型的异常,则发送一条“MESSAGE_POST_CANCEL”的消息;如果顺利执行,则发送一条“MESSAGE_POST_RESULT”的消息,而消息都与一个sHandler对象关联。
我们继续按着执行流程跟踪代码,
// 正在执行任务前的准备处理
onPreExecute();
// 获得从UI现存传递来的参数
mWorker.mParams = params;
// 交给线程池管理器进行调度,参数为FutureTask类型,构造mFuture时mWorker被传递了进去,后边会继续分析
sExecutor.execute(mFuture);
进入到ThreadPoolExecutor的execute函数,如下 :
[java] view plaincopy
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
/*
-
Proceed in 3 steps:
-
- If fewer than corePoolSize threads are running, try to
-
start a new thread with the given command as its first
-
task. The call to addWorker atomically checks runState and
-
workerCount, and so prevents false alarms that would add
-
threads when it shouldn’t, by returning false.
-
- If a task can be successfully queued, then we still need
-
to double-check whether we should have added a thread
-
(because existing ones died since last checking) or that
-
the pool shut down since entry into this method. So we
-
recheck state and if necessary roll back the enqueuing if
-
stopped, or start a new thread if there are none.
-
- If we cannot queue task, then we try to add a new
-
thread. If it fails, we know we are shut down or saturated
-
and so reject the task.
*/
int c = ctl.get();
if (workerCountOf© < corePoolSize) {
if (addWorker(command, true))
return;
c = ctl.get();
}
if (isRunning© && workQueue.offer(command)) {
int recheck = ctl.get();
if (! isRunning(recheck) && remove(command))
reject(command);
else if (workerCountOf(recheck) == 0)
addWorker(null, false);
}
else if (!addWorker(command, false))
reject(command);
}
可以看到,这段代码的主要功能是将异步任务mFuture加入到将要执行的队列中,重要的函数为addWoker,我们继续跟踪代码到该函数。
private boolean addWorker(Runnable firstTask, boolean core) {
retry:
for (;😉 {
int c = ctl.get();
int rs = runStateOf©;
// Check if queue empty only if necessary.
if (rs >= SHUTDOWN &&
! (rs == SHUTDOWN &&
firstTask == null &&
! workQueue.isEmpty()))
return false;
for (;😉 {
int wc = workerCountOf©;
if (wc >= CAPACITY ||
wc >= (core ? corePoolSize : maximumPoolSize))
return false;
if (compareAndIncrementWorkerCount©)
break retry;
c = ctl.get(); // Re-read ctl
if (runStateOf© != rs)
continue retry;
// else CAS failed due to workerCount change; retry inner loop
}
}
// 这里又生成了一个Worker的对象,将异步任务传递给了w
Worker w = new Worker(firstTask);
Thread t = w.thread;
… // 后续代码省略
wokers.add( w );// 将w添加到了wokers里,这是一个HashSet集合对象
…
w.start(); // 启动该异步任务,即启动了mFuture任务。
…
return true;
}
由于mFuture是FutureTask类型,因此继续跟踪到FutureTask的代码。可以看到该构造函数,即上文中构造mFuture时用的构造函数,参数我们传递的是mWorker。
public FutureTask(Callable callable) {
if (callable == null)
throw new NullPointerException();
sync = new Sync(callable);
}
可以看到构造函数又将mWorker交给了Sync类型。
而启动mFuture时就会执行其中的run函数,如下 :
public void run() {
sync.innerRun();
}
可知,实际上调用的是Sync的innerRun()函数,我们继续查看Sync类型。
private volatile Thread runner;
造函数,传递进来的就是最先说的那个mWorker
Sync(Callable callable) {
this.callable = callable;
}
… // 部分代码省略
// innerRun函数
void innerRun() {
if (!compareAndSetState(READY, RUNNING))
return;
runner = Thread.currentThread();
if (getState() == RUNNING) { // recheck after setting thread
V result;
try {
// 可以发现调用的是callable的.call()函数,即mWorker的call函数,而在mWorker的call函数中才真正的调用了doInBackground函数,至此线程真正启动了!
result = callable.call();
} catch (Throwable ex) {
setException(ex);
return;
}
set(result);
} else {
releaseShared(0); // cancel
}
}
我们看到,最后调用了set(result);我们看看这段代码 :
protected void set(V v) {
sync.innerSet(v);
}
我们在看看sync中的innerSet方法 :
void innerSet(V v) {
for (;😉 {
写在最后
在技术领域内,没有任何一门课程可以让你学完后一劳永逸,再好的课程也只能是“师傅领进门,修行靠个人”。“学无止境”这句话,在任何技术领域,都不只是良好的习惯,更是程序员和工程师们不被时代淘汰、获得更好机会和发展的必要前提。
如果你觉得自己学习效率低,缺乏正确的指导,可以一起学习交流!
加入我们吧!群内有许多来自一线的技术大牛,也有在小厂或外包公司奋斗的码农,我们致力打造一个平等,高质量的Android交流圈子,不一定能短期就让每个人的技术突飞猛进,但从长远来说,眼光,格局,长远发展的方向才是最重要的。
35岁中年危机大多是因为被短期的利益牵着走,过早压榨掉了价值,如果能一开始就树立一个正确的长远的职业规划。35岁后的你只会比周围的人更值钱。
网上学习资料一大堆,但如果学到的知识不成体系,遇到问题时只是浅尝辄止,不再深入研究,那么很难做到真正的技术提升。
一个人可以走的很快,但一群人才能走的更远!不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人,都欢迎加入我们的的圈子(技术交流、学习资源、职场吐槽、大厂内推、面试辅导),让我们一起学习成长!