本文讨论一下异步链式调用的设计与实现。
考虑如下情况：
情况1：
访问网络（或其他耗时的事情）。通常的做法是：
1、显示一个ProgressDialog对话框，提示用户。
2、启动工作线程来执行耗时操作。
3、发送消息到关联到主线程的Handler里面，关闭对话框。
情况2：
从网络下载一个zip文件，下载完成之后，询问用户是否执行解压操作。通常的合理做法：
1、显示一个ProgressDialog对话框，提示用户。
2、启动线程执行下载操作。
3、发送消息到关联到主线程的Handler里面，关闭对话框，然后启动一个询问对话框。
4、用户如果点击[YES]，显示一个ProgressDialog对话框。
5、启动用线程执行解压操作。
6、发送消息到关联到主线程的Handler里面，关闭对话框。
通常情况下，在Android我们有两种方式来使用线程，一是Thread + Handler这种标准方式，另外一种是使用AsyncTask类。
实现这两个情况的缺点：
1、定义Handler，发送消息，使得代码变得复杂，不易理解。
2、发送消息是异步处理，在某些情况下可能需要做等待操作。
3、流程执行混乱，不是流水作业。
基于以上情况，我们能不能也像流水线的操作那么调用我们的回调(Callback)，使用者只关心第一步干什么，第二步干什么，如果能这样的话，那么在哪步做什么都能明确定义出来，这就是链式调用。
请看下面的链式调用的写法(JavaScript)：
Async.go(initialArgument)
.next(firstAsyncOperation)
.next(secondAsyncOperation)
.next(thirdAsyncOperation)
.next(function(finalResult) { alert(finalResult); })
用户只需要添加每一步的task到一个队列里面，然后执行，这些task就会按添加的顺序执行，从而实现链式调用。
这种思想还不挺好的，在写代码的时候，我们更加关注实现的逻辑，不需要去考虑发什么消息等。只考虑第一步干什么，第二步干什么等。这样在以后代码维护时也比较好。
我们能不能设计出一个Android版本的异步链式调用的模块呢，请看下面。
Task
我们抽象出每一步要做的事情，定义一个Task类，它是一个抽象类，有如下核心属性和方法：
mRunInBackground
用来指示这个Task是运行在后台线程还是运行在主线程。
onExecuter(TaskOperation)
我们需要实现该方法，在这里面执行我们想要做的事情。
onProgressUpdate(Object)
我们可以重写该方法，来更新我们所做事情的进度，这个方法运行在主线程。
注意：在使用时，你必须指定这个Task是运行在UI线程还是后台线程。
TaskOperation
1）这个类里面包含了task的运行参数，上一个task的输出将会作为下一个task的输入。
2）它可以指示继续或暂停执行下一个task。
3）它里面使用了一个object[]来存储参数。
TaskManager
1）管理task队列，始终从队列第一个开始执行，执行一个task后，这个task将从队列出移除。
2）内部创建了一个带有消息循环的线程。
3）执行task时，判断其运行的线程环境，如果运行在UI线程，发送消息到UI的Handler来执行。
4）内部封装了Handler，用户不用关心是否发送消息。
5）核心方法有：
- next(Task)
- execute()
- execute(TaskOperation)
- cancelCurrentTask()
- removeTasks()
- publishProgress(Object)
这里只是给了一个最基本的设计思路，现在该设计还有完善的地方，具体的实现请参考相关的代码和测试工程。
实现代码
Task.java
/*
* System: CoreLib
* @version 1.00
*
* Copyright (C) 2010, LiHong
*
*/
package com.nj1s.lib.task;
import java.util.concurrent.atomic.AtomicBoolean;
/**
* <p>
* This method define the task used to do something. Typically you should override
* {@link #onExecute(TaskOperation)} method to do you things, on the other hand, you
* also can override the {@link #onProgressUpdate(Object)} method to get the progress of
* you things.
* </p>
*
* <p>
* NOTE:
* There is an very important thing you should pay attention to, you must specify the task
* is running on background thread or UI thread, the default flag is true ---- running on
* background thread.
* </p>
*
* @author LeeHong
*
* @date 2012/10/30
*/
public abstract class Task
{
/**
* The id of the task, typically you need NOT set it, if will set automatically when you
* add this task into {@link TaskManager} class.
*/
private int mId = 0;
/**
* The task name.
*/
private String mName = null;
/**
* Indicate this task is canceled or not.
*/
private AtomicBoolean mCancelled = new AtomicBoolean(false);
/**
* The task status, default value is {@link Status#PENDING}.
*/
private volatile Status mStatus = Status.PENDING;
/**
* The running status, default value is {@link RunningStatus#UI_THREAD}.
*/
private volatile RunningStatus mRunStatus = RunningStatus.UI_THREAD;
/**
* Indicates the current status of the task. Each status will be set only once
* during the lifetime of a task.
*/
public enum Status
{
/**
* Indicates that the task has not been executed yet.
*/
PENDING,
/**
* Indicates that the task is running.
*/
RUNNING,
/**
* Indicates that {@link Task#onExecute} has finished.
*/
FINISHED,
}
/**
* Indicate the task running status.
*/
public enum RunningStatus
{
/**
* Indicate the task is running in the background thread.
*/
WORK_THREAD,
/**
* Indicate the task is running in the UI thread.
*/
UI_THREAD,
}
/**
* The constructor method.
*
* @param runInBackground
* @param name
*/
public Task(Task task)
{
this.mRunStatus = task.mRunStatus;
this.mName = task.mName;
this.mStatus = task.mStatus;
}
/**
* The constructor method.
*
* @param status indicate the task is running in background thread or not.
*/
public Task(RunningStatus status)
{
this(status, null);
}
/**
* The constructor method.
*
* @param runInBackground
* @param name
*/
public Task(RunningStatus status, String name)
{
mRunStatus = status;
mName = name;
}
/**
* Override this method to do you works.
*
* @param operation The operation is passed from previous task.
*
* @return Typically you should return the {@link #operation}.
*/
public abstract TaskOperation onExecute(TaskOperation operation);
/**
* Called when change the progress, this method is running in UI thread.
*
* @param progresses
*/
public void onProgressUpdate(Object progresses)
{
}
/**
* Cancel the task.
*/
public void cancel()
{
mCancelled.set(true);
}
/**
* Indicate the task is canceled or not.
*
* @return
*/
public boolean isCancelled()
{
return mCancelled.get();
}
/**
* Get the running status.
*
* @return
*/
public RunningStatus getRunningStatus()
{
return mRunStatus;
}
/**
* Set the name of the task.
*
* @param name The task name.
*/
public void setTaskName(String name)
{
mName = name;
}
/**
* Get the task name.
*
* @return the task name.
*/
public String getTaskName()
{
return mName;
}
/**
* Set the status of the task.
*
* @param status
*/
public void setStatus(Status status)
{
mStatus = status;
}
/**
* Get the status of the task.
*
* @return
*/
public Status getStatus()
{
return mStatus;
}
/**
* Set the id of the task.
*
* @param id
*/
public void setTaskId(int id)
{
mId = id;
}
/**
* Get the task id.
*/
public int getTaskId()
{
return mId;
}
/**
* @see java.lang.Object#toString()
*/
@Override
public String toString()
{
StringBuilder sb = new StringBuilder();
sb.append("name = ").append(mName).append(" ");
sb.append("id = ").append(mId).append(" ");
sb.append(super.toString());
return sb.toString();
}
}
TaskOperation.java
/*
* System: CoreLib
* @version 1.00
*
* Copyright (C) 2010, LiHong.
*/
package com.nj1s.lib.task;
import java.util.ArrayList;
import com.nj1s.lib.task.TaskManager.TaskManagerState;
/**
* The task operation, it wraps the task parameter, etc.
*
* @author LeeHong
*
* @date 2012/10/30
*/
public class TaskOperation
{
/**
* The task parameter.
*/
private Object[] mNextTaskParams = null;
/**
* The task manager status.
*/
private TaskManagerState mTaskManagerStatus = TaskManagerState.CONTINUE;
/**
* The constructor method.
*/
public TaskOperation()
{
}
/**
* The constructor method.
*
* @param nextTaskParams
*/
public TaskOperation(Object[] nextTaskParams)
{
mNextTaskParams = nextTaskParams;
}
/**
* The constructor method.
*
* @param operation
*/
public TaskOperation(TaskOperation operation)
{
setTaskParams(operation);
}
/**
* Get the task parameter.
*/
public Object[] getTaskParams()
{
return mNextTaskParams;
}
/**
* Set the task parameter.
*
* @param params
*/
public void setTaskParams(Object[] params)
{
mNextTaskParams = params;
}
/**
* Set the task parameters.
*
* @param operation
*/
public void setTaskParams(TaskOperation operation)
{
if (operation == this)
{
throw new IllegalArgumentException("The argument can NOT be self.");
}
if (null == operation)
{
return;
}
Object[] params = operation.getTaskParams();
if (null == params)
{
return;
}
ArrayList<Object> paramsList = new ArrayList<Object>();
if (null != mNextTaskParams)
{
for (Object param : mNextTaskParams)
{
paramsList.add(param);
}
}
for (Object param : params)
{
paramsList.add(param);
}
mNextTaskParams = paramsList.toArray();
}
/**
* @param status the mTaskManagerStatus to set
*/
public void setTaskManagerStatus(TaskManagerState status)
{
mTaskManagerStatus = status;
}
/**
* @return the mTaskManagerStatus
*/
public TaskManagerState getTaskManagerStatus()
{
return mTaskManagerStatus;
}
/**
* Append the specified parameter to the end of the parameter list.
*
* @param param
*/
public void appendTaskParam(Object param)
{
appendTaskParams(new Object[] {param});
}
/**
* Append the specified parameter to the end of the parameter list.
*
* @param params
*/
public void appendTaskParams(Object[] params)
{
if (null != params)
{
TaskOperation operation = new TaskOperation(params);
setTaskParams(operation);
}
}
}
TaskManager.java
/*
* System: CoreLib
* @version 1.00
*
* Copyright (C) 2010, LiHong.
*
*/
package com.nj1s.lib.task;
import java.util.HashMap;
import java.util.LinkedList;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.text.TextUtils;
import android.util.Log;
import com.nj1s.lib.task.Task.RunningStatus;
import com.nj1s.lib.task.Task.Status;
import com.nj1s.lib.thread.ThreadWorker;
/**
* This class is used to manager the tasks so that you can add many tasks into the task manger
* and these tasks will be running one by one.
*
* <h2>Example:</h2>
* <pre class="prettyprint">
* private void showProgressDialog()
* {
* final ProgressDialog mProgressDialog = null;
* final TaskManager taskManager = new TaskManager("ShowProgressDlg");
*
* // Set the state change listener.
* taskManager.setStateChangeListener(new IStateChangeListener()
* {
* public void onStateChanged(TaskManager taskManager, State oldState, State newState)
* {
* Toast.makeText(ShowProgressDlgActivity.this, " onStateChanged state = " + newState, Toast.LENGTH_SHORT).show();
* }
* });
*
* taskManager
* .next(new Task(Task.RunningStatus.UI_THREAD)
* {
* public TaskOperation onExecute(TaskOperation operation)
* {
* mProgressDialog = new ProgressDialog(ShowProgressDlgActivity.this);
* mProgressDialog.setTitle("Download");
* mProgressDialog.setMessage("Downlonding data from server...");
* mProgressDialog.setCancelable(false);
* mProgressDialog.show();
*
* return null;
* }
* })
* .next(new Task(Task.RunningStatus.WORK_THREAD)
* {
* public TaskOperation onExecute(TaskOperation operation)
* {
* // Simulate the work thread.
* sleep(5000);
*
* return null;
* }
* })
* .next(new Task(Task.RunningStatus.UI_THREAD)
* {
* public TaskOperation onExecute(TaskOperation operation)
* {
* if (null != mProgressDialog && mProgressDialog.isShowing())
* {
* mProgressDialog.dismiss();
* mProgressDialog = null;
* }
*
* return null;
* }
* })
* .execute(); // Call this method to execute these tasks.
* }
* </pre>
*
* <h2>Note:</h2>
* <pre>
* The {@link Task} class must be specified the task running state, one of the enum {@link Task#RunningStatus}.
* </pre>
*
* @author LeeHong
*
* @date 2012/10/30
*
* @see {@link Task}
* @see {@link TaskOperation}
*/
public class TaskManager
{
/**
* Execute task message.
*/
private static final int MESSAGE_POST_EXECUTE = 0x01;
/**
* Update progress message.
*/
private static final int MESSAGE_POST_PROGRESS = 0x02;
/**
* The state change listener.
*/
public interface IStateChangeListener
{
/**
* Called when the task manager's state is changed. This method will be called in
* UI thread.
*
* @param taskManager Which task manager's state changed.
* @param oldState The old state.
* @param newState The new state.
*/
public void onStateChanged(TaskManager taskManager, State oldState, State newState);
}
/**
* A representation of a task manager's state. A given thread may only be in one
* state at a time.
*/
public enum State
{
/**
* The task manager has been created, but has never been started.
*/
NEW,
/**
* Indicate the task manager is running one task.
*/
RUNNING,
/**
* Indicate the task manager is paused, typically call {@link #pause()} method.
*/
PAUSED,
/**
* All tasks are finished.
*/
FINISHED,
}
/**
* The status of the {@link TaskManager} class.
*/
public enum TaskManagerState
{
/**
* Continue the task manager to run next task.
*/
CONTINUE,
/**
* Indicate the task manager pause to run next task.
*/
PAUSE,
}
/**
* The running task manager collection.
*/
private static HashMap<String, TaskManager> s_taskManagers = new HashMap<String, TaskManager>();
/**
* The task list.
*/
private LinkedList<Task> mTaskList = new LinkedList<Task>();
/**
* The task operation, it will pass from first task to the last task.
*/
private TaskOperation mTaskOperation = new TaskOperation();
/**
* The running thread worker, it own a looper which will be alive until you call
* {@link ThreadWorker#quit()} method.
*/
private ThreadWorker mThreadWorker = null;
/**
* The current perform task, may be null.
*/
private Task mCurTask = null;
/**
* The state of the task manager.
*/
private State mState = State.NEW;
/**
* The name of the task manager.
*/
private String mName = null;
/**
* The listener.
*/
private IStateChangeListener mListener = null;
/**
* The background thread handler, which is associated to a background thread looper.
*/
private Handler mThreadHandler = null;
/**
* The UI thread handler.
*/
private Handler mUIHandler = new Handler(Looper.getMainLooper())
{
@Override
public void handleMessage(Message msg)
{
switch (msg.what)
{
case MESSAGE_POST_EXECUTE:
Task task = (Task)msg.obj;
executeTask(task);
// Try to run next task if possible.
runNextTask();
break;
case MESSAGE_POST_PROGRESS:
postProgress(msg.obj);
break;
}
}
};
/**
* The constructor method.
*/
public TaskManager()
{
}
/**
* The constructor method.
*
* @param name The name of the task manager.
*/
public TaskManager(String name)
{
mName = name;
}
/**
* Add the task to {@link TaskManager} class.
*
* @param task The task.
*
* @return the {@link TaskManager} object.
*/
public TaskManager next(Task task)
{
if (null != task)
{
synchronized (mTaskList)
{
int id = mTaskList.size() + 1;
task.setTaskId(id);
mTaskList.add(task);
}
}
else
{
throw new NullPointerException("task is null");
}
return this;
}
/**
* Start to execute the tasks in the task manager.
*/
public void execute()
{
if (mTaskList.size() > 0)
{
startThread();
// Set the task to RUNNING.
setState(State.RUNNING);
// Perform the runnable in the handler which is associated to the background thread.
mThreadHandler.post(new Runnable()
{
@Override
public void run()
{
doInBackground();
}
});
}
else
{
quitLooper();
}
}
/**
* Start to execute the tasks in the task manager with the specified parameter.
*
* @param operation The task operation contains the task parameter.
*/
public void execute(TaskOperation operation)
{
if (null != operation)
{
mTaskOperation = operation;
}
execute();
}
/**
* Post execute a task which will be running in UI thread.
*
* @param task the task to be running.
*/
public void postExecute(Task task)
{
if (null == task)
{
throw new NullPointerException("Task can NOT be null.");
}
final Task runTask = task;
// If the task running status is UI_THREAD.
if (RunningStatus.UI_THREAD == runTask.getRunningStatus())
{
// The task is running in UI thread.
mUIHandler.post(new Runnable()
{
@Override
public void run()
{
executeTask(runTask);
}
});
}
}
/**
* Publish the task progress, if you call this method, the {@link Task#onProgressUpdate(Object)}
* method will be called, which is running in the UI thread.
*
* @param progresses The progress.
*/
public void publishProgress(Object progresses)
{
mUIHandler.obtainMessage(MESSAGE_POST_PROGRESS, progresses).sendToTarget();
}
/**
* Cancel the current running task.
*/
public void cancelCurrentTask()
{
if (null != mCurTask)
{
mCurTask.cancel();
}
}
/**
* Remove the tasks in the list.
*/
public void removeTasks()
{
synchronized (mTaskList)
{
if (mTaskList.size() > 0)
{
mTaskList.clear();
quitLooper();
}
}
}
/**
* Remove the specified task.
*
* @param task The task to be removed.
*/
public void removeTask(Task task)
{
synchronized (mTaskList)
{
mTaskList.remove(task);
if (mTaskList.isEmpty())
{
quitLooper();
}
}
}
/**
* Set the state change listener.
*
* @param listener
*/
public void setStateChangeListener(IStateChangeListener listener)
{
mListener = listener;
}
/**
* Get the task operation.
*
* @return
*/
public TaskOperation getTaskOperation()
{
return mTaskOperation;
}
/**
* @return the mName
*/
public String getName()
{
return mName;
}
/**
* Pause the worker thread.
*/
public void pause()
{
if (null != mThreadWorker)
{
setState(State.PAUSED);
mThreadWorker.pause();
}
}
/**
* Resume the worker thread from the waiting status.
*/
public void resume()
{
if (null != mThreadWorker)
{
setState(State.RUNNING);
mThreadWorker.restart();
}
}
/**
* Quit the looper so that the thread can finish correctly.
*/
public void quitLooper()
{
if (null != mThreadWorker)
{
mThreadWorker.quit();
mThreadWorker = null;
}
mThreadHandler = null;
// Set the task to FINISHED.
setState(State.FINISHED);
}
/**
* Blocks the current thread ({@link Thread#currentThread()}) until the receiver finishes its execution and dies.
*/
public final void join()
{
if (null != mThreadWorker)
{
mThreadWorker.join();
}
}
/**
* Get the task manager state.
*
* @return
*/
public State getState()
{
return mState;
}
/**
* Get the running task manager.
*
* @return HashMap<String, TaskManager>, the task manager's name is the key, and the
* task manager object is the value.
*/
public static HashMap<String, TaskManager> getTaskManagers()
{
return s_taskManagers;
}
/**
* @see java.lang.Object#toString()
*/
@Override
public String toString()
{
StringBuilder sb = new StringBuilder();
sb.append("Name = ").append(mName).append(" ");
sb.append("State = ").append(mState).append(" ");
sb.append(super.toString());
return sb.toString();
}
/**
* print task execute status
*
* @param task
*/
protected void printExecuteTaskState(Task task)
{
Log.d("TaskManager", " Executer the task: " + task.toString());
}
/**
* Set the state.
*
* @param state
*/
private void setState(State state)
{
final State oldState = mState;
final State newState = state;
mState = state;
if (mState == State.FINISHED)
{
popTaskManager(this);
}
else
{
pushTaskManager(this);
}
if (oldState != newState)
{
printTaskManagerState(oldState, newState);
performStateChange(oldState, newState);
}
}
/**
* Call this method to start the work thread if can.
*/
private void startThread()
{
if (null == mThreadWorker)
{
String name = TextUtils.isEmpty(mName) ? this.toString() : mName;
String threadName = "TaskManager_Thread_" + name;
mThreadWorker = new ThreadWorker(threadName);
mThreadHandler = new Handler(mThreadWorker.getLooper());
}
}
/**
* This method is running in the background thread.
*/
private void doInBackground()
{
mCurTask = null;
if (mTaskList.isEmpty())
{
return;
}
Task task = mTaskList.get(0);
mCurTask = task;
// Remove the first item in the list.
synchronized (mTaskList)
{
mTaskList.remove(0);
}
// If the task is allowed to be running in background thread, we execute the task
// now, the doInBackground() method is running in the background thread.
switch (task.getRunningStatus())
{
case WORK_THREAD:
executeTask(task);
// Try to run next task if possible.
runNextTask();
break;
case UI_THREAD:
// Send a message to the UI handler to executer the task.
mUIHandler.obtainMessage(MESSAGE_POST_EXECUTE, task).sendToTarget();
break;
}
}
/**
* Run the next task.
*/
private void runNextTask()
{
// If run next, call the execute() method again.
if (isRunNext())
{
execute();
}
}
/**
* Check whether run the next task if has one.
*
* @return true if run next task, otherwise false.
*/
private boolean isRunNext()
{
boolean isRunNext = true;
boolean hasNext = false;
if (null != mTaskOperation)
{
isRunNext = (mTaskOperation.getTaskManagerStatus() == TaskManagerState.CONTINUE);
}
if (null != mTaskList)
{
hasNext = mTaskList.size() > 0;
}
// No next task, quit the thread.
if (!hasNext)
{
quitLooper();
}
return (isRunNext && hasNext);
}
/**
* Execute the task, if will call {@link Task#onExecute(TaskOperation)} method.
*
* @param task The task object.
*/
private void executeTask(Task task)
{
if (null != task)
{
// Set the status of the task.
task.setStatus(Status.RUNNING);
// Print the task state.
this.printExecuteTaskState(task);
try
{
// Avoid the exception from task interrupting the task manager works.
mTaskOperation = task.onExecute(mTaskOperation);
}
catch (Exception e)
{
e.printStackTrace();
}
// Set the status of the task.
task.setStatus(Status.FINISHED);
// Print the task state.
this.printExecuteTaskState(task);
}
}
/**
* Post the progress, it will call {@link Task#onProgressUpdate(Object progresses)} method.
*
* @param progresses
*/
private void postProgress(Object progresses)
{
if (null != mCurTask)
{
mCurTask.onProgressUpdate(progresses);
}
}
/**
* Perform the state change.
*
* @param oldState
* @param newState
*/
private void performStateChange(final State oldState, final State newState)
{
if (null != mListener)
{
mUIHandler.post(new Runnable()
{
@Override
public void run()
{
mListener.onStateChanged(TaskManager.this, oldState, newState);
}
});
}
}
/**
* Print the task manager information.
*
* @param oldState
* @param newState
*/
private void printTaskManagerState(final State oldState, final State newState)
{
Log.d("TaskManager", "TaskManager state changed, task manager = " + this.toString());
}
/**
* Push the task manager to the list.
*
* @param taskManager
*/
private static void pushTaskManager(TaskManager taskManager)
{
if (null != taskManager)
{
String name = taskManager.getName();
if (!TextUtils.isEmpty(name))
{
s_taskManagers.put(name, taskManager);
}
}
}
/**
* Pop the task manager from the list.
* @param taskManager
*/
private static void popTaskManager(TaskManager taskManager)
{
if (null != taskManager)
{
String name = taskManager.getName();
s_taskManagers.remove(name);
}
}
}