在使用AsyncTask的时候我们可以看到几个明显的缺陷和问题
2012-10-17 10:45
344 查看
/**
在使用AsyncTask的时候我们可以看到几个明显的缺陷和问题：
主要针对UI线程；
无法处理异常情况；
线程池里面维护的线程数量过多（CORE_POOL_SIZE默认是5个）；
所以针对以上弊端，我重写了该类，希望对大家有所帮助，另外如有不如意的地方，还请大家指正：
***/
import Android.content.Context;
import android.os.Handler;
import android.os.Message;
import android.os.Process;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeoutException;
import java.util.concurrent.CancellationException;
import java.util.concurrent.atomic.AtomicInteger;
/**
* <p>UserTask是一个为了提高应用性能和能够处理各种异常的一个能运行在前后台的线程池框架.</p>
*
* <p>UserTask运行在后台，可以只处理后台数据，也可以将后台数据展现在前台UI界面上。
* UserTask定义了3个泛型参数，分别是： <code>Params</code>, <code>Progress</code> 和 <code>Result</code>
*
* <h2>使用</h2>
* <p>1.在使用UserTask的时候，首先是实现一个继承它的类. 子类至少需要override
* ({@link #onErrorHandle})和({@link #onTaskFinished}.)</p>
*
* <p>下面是创建子类的例子:</p>
* <pre class="prettyprint">
* private final class DownloadTaskManager extends UserTask<Integer, Integer, Boolean> {
* protected void onErrorHandle(Context context, Exception error) {
* mLog.debug("onErrorHandle : " + error.getMessage());
* }
*
* protected void onTaskFinished(Context context, Boolean result) {
*
* }
* }
* </pre>
*
* 接着需要在调用继承实现的子类对象的registerCallback方法里面去添加任务。
* <pre class="prettyprint">
* final DownloadTaskManager manager = new DownloadTaskManager();
* //final FileDownloader downloader = new FileDownloader(DownloadService.this);
* manager.registerCallback(new TaskCallback() {
* public Object call(UserTask task, Integer[] params) throws Exception {
* //需要后台的操作
* }
* });
* </pre>
*/
public abstract class UserTask<Params, Progress, Result> {
/** The Constant CORE_POOL_SIZE. */
private static final int CORE_POOL_SIZE = 2;
/** The Constant MAXIMUM_POOL_SIZE. */
private static final int MAXIMUM_POOL_SIZE = 32;
/** The Constant KEEP_ALIVE. */
private static final int KEEP_ALIVE = 15;
/** The Constant mWorkQueue. */
private static final BlockingQueue<Runnable> mWorkQueue =
new LinkedBlockingQueue<Runnable>(MAXIMUM_POOL_SIZE);
/** The Constant mThreadFactory. */
private static final ThreadFactory mThreadFactory = new ThreadFactory() {
private final AtomicInteger mCount = new AtomicInteger(1);
public Thread newThread(Runnable r) {
return new Thread(r, "UserTask #" + mCount.getAndIncrement());
}
};
/** The Constant mExecutor. */
private static final ThreadPoolExecutor mExecutor = new ThreadPoolExecutor(CORE_POOL_SIZE,
MAXIMUM_POOL_SIZE, KEEP_ALIVE, TimeUnit.SECONDS, mWorkQueue, mThreadFactory);
/** The Constant MESSAGE_POST_RESULT. */
private static final int MESSAGE_POST_RESULT = 0x1;
/** The Constant MESSAGE_POST_PROGRESS. */
private static final int MESSAGE_POST_PROGRESS = 0x2;
/** The Constant MESSAGE_POST_CANCEL. */
private static final int MESSAGE_POST_CANCEL = 0x3;
/** The Constant mHandler. */
private static final InternalHandler mHandler = new InternalHandler();
/** The m worker. */
private final WorkerRunnable<Params, Result> mWorker;
/** The m future. */
private final FutureTask<Result> mFuture;
/** The m status. */
private volatile Status mStatus = Status.PENDING;
/** The m error. */
protected Exception mError;
/** The m callbask. */
private TaskCallback<Params, Progress, Result> mCallback;
private Context mContext;
/**
* 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 UserTask#onTaskFinished} has finished.
*/
FINISHED,
}
/**
* UserTask的构造函数.
*
*/
public UserTask() {
mWorker = new WorkerRunnable<Params, Result>() {
public Result call() throws Exception {
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
return onBackgroundExecute(mParams);
}
};
mFuture = new FutureTask<Result>(mWorker) {
@Override
protected void done() {
Message message;
Result result = null;
try {
result = get();
} catch (InterruptedException e) {
} catch (ExecutionException e) {
throw new RuntimeException("An error occured while executing doInBackground()",
e.getCause());
} catch (CancellationException e) {
message = mHandler.obtainMessage(MESSAGE_POST_CANCEL,
new UserTaskResult<Result>(UserTask.this, (Result[]) null));
message.sendToTarget();
return;
} catch (Throwable t) {
throw new RuntimeException("An error occured while executing "
+ "doInBackground()", t);
}
//if(result == null) return; //赵小刚：If the result is null, return.
message = mHandler.obtainMessage(MESSAGE_POST_RESULT,
new UserTaskResult<Result>(UserTask.this, result));
message.sendToTarget();
}
};
}
/**
* UserTask的构造函数.
*
*/
public UserTask(Context context) {
mContext = context;
mWorker = new WorkerRunnable<Params, Result>() {
public Result call() throws Exception {
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
return onBackgroundExecute(mParams);
}
};
mFuture = new FutureTask<Result>(mWorker) {
@Override
protected void done() {
Message message;
Result result = null;
try {
result = get();
} catch (InterruptedException e) {
} catch (ExecutionException e) {
throw new RuntimeException("An error occured while executing doInBackground()",
e.getCause());
} catch (CancellationException e) {
message = mHandler.obtainMessage(MESSAGE_POST_CANCEL,
new UserTaskResult<Result>(UserTask.this, (Result[]) null));
message.sendToTarget();
return;
} catch (Throwable t) {
throw new RuntimeException("An error occured while executing "
+ "doInBackground()", t);
}
//if(result == null) return; //赵小刚：If the result is null, return.
message = mHandler.obtainMessage(MESSAGE_POST_RESULT,
new UserTaskResult<Result>(UserTask.this, result));
message.sendToTarget();
}
};
}
/**
*返回当前任务的状态.
*
* @return The current status.
*/
public final Status getStatus() {
return mStatus;
}
/**
* 注册任务回调方法.
*
* @param callback the callback
*/
public void registerCallback(TaskCallback<Params, Progress, Result> callback) {
this.mCallback = callback;
}
/**
* 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 thread.
*
* @param params The parameters of the task.
*
* @return A result, defined by the subclass of this task.
*
* @see #onPreExecute()
* @see #onPostExecute
* @see #publishProgress
*/
protected Result onBackgroundExecute(Params... params) {
Result result = null;
try {
result = onCallbackExecute(params);
} catch (Exception e) {
this.mError = e;
}
return result;
}
/**
* Override to perform computation in a background thread.
*
* @param params the params
* @return the result
* @throws Exception the exception
*/
protected Result onCallbackExecute(Params... params) throws Exception {
return mCallback.call(UserTask.this, params);
}
/**
* Runs in the thread if there was an exception throw from onCallbackExecute.
*
* @param error The thrown exception.
*/
protected abstract void onErrorHandle(Context context, Exception error);
/**
* A replacement for onPostExecute. Runs in the thread after onCallbackExecute returns.
*
* @param result The result returned from onCallbackExecute
*/
protected abstract void onTaskFinished(Context context, Result result);
/**
* 在 {@link #onBackgroundExecute}之前执行.
*
* @see #onTaskPrepare
* @see #onBackgroundExecute
*/
protected void onTaskPrepare() {
}
/**
* 本方法在{@link #onBackgroundExecute}之后执行. The
* specified result is the value returned by {@link #onBackgroundExecute}
* or null if the task was cancelled or an exception occured.
*
* @param result The result of the operation computed by {@link #onBackgroundExecute}.
*
* @see #onPreExecute
* @see #onBackgroundExecute
*/
@SuppressWarnings({"UnusedDeclaration"})
protected void onPostExecute(Result result) {
if (onTaskFailed()) {
onErrorHandle(mContext, mError);
} else {
onTaskFinished(mContext, result);
}
}
/**
* 本方法的执行需要在在{@link #publishProgress}被调用之后.
* The specified values are the values passed to {@link #publishProgress}.
*
* @param values The values indicating progress.
*
* @see #publishProgress
* @see #onBackgroundExecute
*/
@SuppressWarnings({"UnusedDeclaration"})
protected void onProgressUpdate(Progress... values) {
}
/**
* Has an exception been thrown inside doCheckedInBackground().
*
* @return true, if successful
*/
protected boolean onTaskFailed() {
return mError != null;
}
/**
* 在{@link #cancel(boolean)}被执行之后才能执行本方法.
*
* @see #cancel(boolean)
* @see #isCancelled()
*/
protected void onCancelled() {
}
/**
* Returns <tt>true</tt> if this task was cancelled before it completed
* normally.
*
* @return <tt>true</tt> if task was cancelled before it completed
*
* @see #cancel(boolean)
*/
public final boolean isCancelled() {
return mFuture.isCancelled();
}
/**
* Attempts to cancel execution of this task. This attempt will
* fail if the task has already completed, already been cancelled,
* or could not be cancelled for some other reason. If successful,
* and this task has not started when <tt>cancel</tt> is called,
* this task should never run. If the task has already started,
* then the <tt>mayInterruptIfRunning</tt> parameter determines
* whether the thread executing this task should be interrupted in
* an attempt to stop the task.
*
* @param mayInterruptIfRunning <tt>true</tt> if the thread executing this
* task should be interrupted; otherwise, in-progress tasks are allowed
* to complete.
*
* @return <tt>false</tt> if the task could not be cancelled,
* typically because it has already completed normally;
* <tt>true</tt> otherwise
*
* @see #isCancelled()
* @see #onCancelled()
*/
public final boolean cancel(boolean mayInterruptIfRunning) {
return mFuture.cancel(mayInterruptIfRunning);
}
/**
* Waits if necessary for the computation to complete, and then
* retrieves its result.
*
* @return The computed result.
* @throws InterruptedException If the current thread was interrupted
* while waiting.
* @throws ExecutionException If the computation threw an exception.
*/
public final Result get() throws InterruptedException, ExecutionException {
return mFuture.get();
}
/**
* Waits if necessary for at most the given time for the computation
* to complete, and then retrieves its result.
*
* @param timeout Time to wait before cancelling the operation.
* @param unit The time unit for the timeout.
* @return The computed result.
* @throws InterruptedException If the current thread was interrupted
* while waiting.
* @throws ExecutionException If the computation threw an exception.
* @throws TimeoutException If the wait timed out.
*/
public final Result get(long timeout, TimeUnit unit) throws InterruptedException,
ExecutionException, TimeoutException {
return mFuture.get(timeout, unit);
}
/**
* execute方法返回自己(this),因此调用者可以保存它的引用
*
* 该方法可以在任何一个地方执行
*
* @param params The parameters of the task.
* @return This instance of UserTask.
* {@link UserTask.Status#RUNNING} or {@link UserTask.Status#FINISHED}.
*/
public final UserTask<Params, Progress, Result> execute(Params... params) {
if (mStatus != Status.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;
onTaskPrepare();
mWorker.mParams = params;
mExecutor.execute(mFuture);
return this;
}
/**
* This method can be invoked from {@link #onBackgroundExecute} to
* publish updates on the thread while the background computation is
* still running. Each call to this method will trigger the execution of
*
* @param values The progress values to update the result.
* {@link #onProgressUpdate}
* @see #onProgressUpdate
* @see #onBackgroundExecute
*/
public final void publishProgress(Progress... values) {
mHandler.obtainMessage(MESSAGE_POST_PROGRESS,
new UserTaskResult<Progress>(this, values)).sendToTarget();
}
/**
* Finish.
*
* @param result the result
*/
private void finish(Result result) {
if (isCancelled()) result = null;
onPostExecute(result);
mStatus = Status.FINISHED;
}
/**
* The Class InternalHandler.
*/
private static class InternalHandler extends Handler {
/* (non-Javadoc)
* @see android.os.Handler#handleMessage(android.os.Message)
*/
@SuppressWarnings({"unchecked", "RawUseOfParameterizedType"})
public void handleMessage(Message msg) {
UserTaskResult result = (UserTaskResult) 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;
case MESSAGE_POST_CANCEL:
result.mTask.onCancelled();
break;
}
}
}
/**
* The Class WorkerRunnable.
*
* @param <Params> the generic type
* @param <Result> the generic type
*/
private static abstract class WorkerRunnable<Params, Result> implements Callable<Result> {
/** The m params. */
Params[] mParams;
}
/**
* The Class UserTaskResult.
*
* @param <Data> the generic type
*/
@SuppressWarnings({"RawUseOfParameterizedType", "unchecked"})
private static class UserTaskResult<Data> {
/** The m task. */
final UserTask mTask;
/** The m data. */
final Data[] mData;
/**
* UserTaskResult的构造函数
*
* @param task the task
* @param data the data
*/
UserTaskResult(UserTask task, Data... data) {
mTask = task;
mData = data;
}
}
/**
* TaskCallback接口用于实现UserTask的registerCallback方法.
*
* @param <Params> the generic type
* @param <Progress> the generic type
* @param <Result> the generic type
*/
public interface TaskCallback<Params, Progress, Result> {
/**
* 耗时操作都放在在call方法里面
*
* @param task the task
* @return the result
* @throws AppException the app exception
*/
public Result call(UserTask<Params, Progress, Result> task, Params[] params) throws Exception;
}
}
//下面是一个使用该类的实例：
public class MainActivity extends Activity {
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
handlePrinter();
}
private void handlePrinter() {
final PrinterTask task = new PrinterTask(this);
task.registerCallback(new TaskCallback<Integer, Void, Integer>() {
@Override
public Integer call(UserTask<Integer, Void, Integer> task, Integer[] params)
throws Exception {
final int time = params[0];
android.util.Log.d("TAG", String.valueOf(time));
SystemClock.sleep(time);
return 0;
}
});
task.execute(5000);
}
private class PrinterTask extends UserTask<Integer, Void, Integer>{
public PrinterTask(Context context) {
super(context);
}
@Override
protected void onTaskPrepare() {
// TODO Auto-generated method stub
super.onTaskPrepare();
}
@Override
protected void onErrorHandle(Context context, Exception error) {
// TODO Auto-generated method stub
}
@Override
protected void onTaskFinished(Context context, Integer result) {
Toast.makeText(context, "5s", Toast.LENGTH_SHORT).show();
}
}
}
在使用AsyncTask的时候我们可以看到几个明显的缺陷和问题：
主要针对UI线程；
无法处理异常情况；
线程池里面维护的线程数量过多（CORE_POOL_SIZE默认是5个）；
所以针对以上弊端，我重写了该类，希望对大家有所帮助，另外如有不如意的地方，还请大家指正：
***/
import Android.content.Context;
import android.os.Handler;
import android.os.Message;
import android.os.Process;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeoutException;
import java.util.concurrent.CancellationException;
import java.util.concurrent.atomic.AtomicInteger;
/**
* <p>UserTask是一个为了提高应用性能和能够处理各种异常的一个能运行在前后台的线程池框架.</p>
*
* <p>UserTask运行在后台，可以只处理后台数据，也可以将后台数据展现在前台UI界面上。
* UserTask定义了3个泛型参数，分别是： <code>Params</code>, <code>Progress</code> 和 <code>Result</code>
*
* <h2>使用</h2>
* <p>1.在使用UserTask的时候，首先是实现一个继承它的类. 子类至少需要override
* ({@link #onErrorHandle})和({@link #onTaskFinished}.)</p>
*
* <p>下面是创建子类的例子:</p>
* <pre class="prettyprint">
* private final class DownloadTaskManager extends UserTask<Integer, Integer, Boolean> {
* protected void onErrorHandle(Context context, Exception error) {
* mLog.debug("onErrorHandle : " + error.getMessage());
* }
*
* protected void onTaskFinished(Context context, Boolean result) {
*
* }
* }
* </pre>
*
* 接着需要在调用继承实现的子类对象的registerCallback方法里面去添加任务。
* <pre class="prettyprint">
* final DownloadTaskManager manager = new DownloadTaskManager();
* //final FileDownloader downloader = new FileDownloader(DownloadService.this);
* manager.registerCallback(new TaskCallback() {
* public Object call(UserTask task, Integer[] params) throws Exception {
* //需要后台的操作
* }
* });
* </pre>
*/
public abstract class UserTask<Params, Progress, Result> {
/** The Constant CORE_POOL_SIZE. */
private static final int CORE_POOL_SIZE = 2;
/** The Constant MAXIMUM_POOL_SIZE. */
private static final int MAXIMUM_POOL_SIZE = 32;
/** The Constant KEEP_ALIVE. */
private static final int KEEP_ALIVE = 15;
/** The Constant mWorkQueue. */
private static final BlockingQueue<Runnable> mWorkQueue =
new LinkedBlockingQueue<Runnable>(MAXIMUM_POOL_SIZE);
/** The Constant mThreadFactory. */
private static final ThreadFactory mThreadFactory = new ThreadFactory() {
private final AtomicInteger mCount = new AtomicInteger(1);
public Thread newThread(Runnable r) {
return new Thread(r, "UserTask #" + mCount.getAndIncrement());
}
};
/** The Constant mExecutor. */
private static final ThreadPoolExecutor mExecutor = new ThreadPoolExecutor(CORE_POOL_SIZE,
MAXIMUM_POOL_SIZE, KEEP_ALIVE, TimeUnit.SECONDS, mWorkQueue, mThreadFactory);
/** The Constant MESSAGE_POST_RESULT. */
private static final int MESSAGE_POST_RESULT = 0x1;
/** The Constant MESSAGE_POST_PROGRESS. */
private static final int MESSAGE_POST_PROGRESS = 0x2;
/** The Constant MESSAGE_POST_CANCEL. */
private static final int MESSAGE_POST_CANCEL = 0x3;
/** The Constant mHandler. */
private static final InternalHandler mHandler = new InternalHandler();
/** The m worker. */
private final WorkerRunnable<Params, Result> mWorker;
/** The m future. */
private final FutureTask<Result> mFuture;
/** The m status. */
private volatile Status mStatus = Status.PENDING;
/** The m error. */
protected Exception mError;
/** The m callbask. */
private TaskCallback<Params, Progress, Result> mCallback;
private Context mContext;
/**
* 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 UserTask#onTaskFinished} has finished.
*/
FINISHED,
}
/**
* UserTask的构造函数.
*
*/
public UserTask() {
mWorker = new WorkerRunnable<Params, Result>() {
public Result call() throws Exception {
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
return onBackgroundExecute(mParams);
}
};
mFuture = new FutureTask<Result>(mWorker) {
@Override
protected void done() {
Message message;
Result result = null;
try {
result = get();
} catch (InterruptedException e) {
} catch (ExecutionException e) {
throw new RuntimeException("An error occured while executing doInBackground()",
e.getCause());
} catch (CancellationException e) {
message = mHandler.obtainMessage(MESSAGE_POST_CANCEL,
new UserTaskResult<Result>(UserTask.this, (Result[]) null));
message.sendToTarget();
return;
} catch (Throwable t) {
throw new RuntimeException("An error occured while executing "
+ "doInBackground()", t);
}
//if(result == null) return; //赵小刚：If the result is null, return.
message = mHandler.obtainMessage(MESSAGE_POST_RESULT,
new UserTaskResult<Result>(UserTask.this, result));
message.sendToTarget();
}
};
}
/**
* UserTask的构造函数.
*
*/
public UserTask(Context context) {
mContext = context;
mWorker = new WorkerRunnable<Params, Result>() {
public Result call() throws Exception {
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
return onBackgroundExecute(mParams);
}
};
mFuture = new FutureTask<Result>(mWorker) {
@Override
protected void done() {
Message message;
Result result = null;
try {
result = get();
} catch (InterruptedException e) {
} catch (ExecutionException e) {
throw new RuntimeException("An error occured while executing doInBackground()",
e.getCause());
} catch (CancellationException e) {
message = mHandler.obtainMessage(MESSAGE_POST_CANCEL,
new UserTaskResult<Result>(UserTask.this, (Result[]) null));
message.sendToTarget();
return;
} catch (Throwable t) {
throw new RuntimeException("An error occured while executing "
+ "doInBackground()", t);
}
//if(result == null) return; //赵小刚：If the result is null, return.
message = mHandler.obtainMessage(MESSAGE_POST_RESULT,
new UserTaskResult<Result>(UserTask.this, result));
message.sendToTarget();
}
};
}
/**
*返回当前任务的状态.
*
* @return The current status.
*/
public final Status getStatus() {
return mStatus;
}
/**
* 注册任务回调方法.
*
* @param callback the callback
*/
public void registerCallback(TaskCallback<Params, Progress, Result> callback) {
this.mCallback = callback;
}
/**
* 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 thread.
*
* @param params The parameters of the task.
*
* @return A result, defined by the subclass of this task.
*
* @see #onPreExecute()
* @see #onPostExecute
* @see #publishProgress
*/
protected Result onBackgroundExecute(Params... params) {
Result result = null;
try {
result = onCallbackExecute(params);
} catch (Exception e) {
this.mError = e;
}
return result;
}
/**
* Override to perform computation in a background thread.
*
* @param params the params
* @return the result
* @throws Exception the exception
*/
protected Result onCallbackExecute(Params... params) throws Exception {
return mCallback.call(UserTask.this, params);
}
/**
* Runs in the thread if there was an exception throw from onCallbackExecute.
*
* @param error The thrown exception.
*/
protected abstract void onErrorHandle(Context context, Exception error);
/**
* A replacement for onPostExecute. Runs in the thread after onCallbackExecute returns.
*
* @param result The result returned from onCallbackExecute
*/
protected abstract void onTaskFinished(Context context, Result result);
/**
* 在 {@link #onBackgroundExecute}之前执行.
*
* @see #onTaskPrepare
* @see #onBackgroundExecute
*/
protected void onTaskPrepare() {
}
/**
* 本方法在{@link #onBackgroundExecute}之后执行. The
* specified result is the value returned by {@link #onBackgroundExecute}
* or null if the task was cancelled or an exception occured.
*
* @param result The result of the operation computed by {@link #onBackgroundExecute}.
*
* @see #onPreExecute
* @see #onBackgroundExecute
*/
@SuppressWarnings({"UnusedDeclaration"})
protected void onPostExecute(Result result) {
if (onTaskFailed()) {
onErrorHandle(mContext, mError);
} else {
onTaskFinished(mContext, result);
}
}
/**
* 本方法的执行需要在在{@link #publishProgress}被调用之后.
* The specified values are the values passed to {@link #publishProgress}.
*
* @param values The values indicating progress.
*
* @see #publishProgress
* @see #onBackgroundExecute
*/
@SuppressWarnings({"UnusedDeclaration"})
protected void onProgressUpdate(Progress... values) {
}
/**
* Has an exception been thrown inside doCheckedInBackground().
*
* @return true, if successful
*/
protected boolean onTaskFailed() {
return mError != null;
}
/**
* 在{@link #cancel(boolean)}被执行之后才能执行本方法.
*
* @see #cancel(boolean)
* @see #isCancelled()
*/
protected void onCancelled() {
}
/**
* Returns <tt>true</tt> if this task was cancelled before it completed
* normally.
*
* @return <tt>true</tt> if task was cancelled before it completed
*
* @see #cancel(boolean)
*/
public final boolean isCancelled() {
return mFuture.isCancelled();
}
/**
* Attempts to cancel execution of this task. This attempt will
* fail if the task has already completed, already been cancelled,
* or could not be cancelled for some other reason. If successful,
* and this task has not started when <tt>cancel</tt> is called,
* this task should never run. If the task has already started,
* then the <tt>mayInterruptIfRunning</tt> parameter determines
* whether the thread executing this task should be interrupted in
* an attempt to stop the task.
*
* @param mayInterruptIfRunning <tt>true</tt> if the thread executing this
* task should be interrupted; otherwise, in-progress tasks are allowed
* to complete.
*
* @return <tt>false</tt> if the task could not be cancelled,
* typically because it has already completed normally;
* <tt>true</tt> otherwise
*
* @see #isCancelled()
* @see #onCancelled()
*/
public final boolean cancel(boolean mayInterruptIfRunning) {
return mFuture.cancel(mayInterruptIfRunning);
}
/**
* Waits if necessary for the computation to complete, and then
* retrieves its result.
*
* @return The computed result.
* @throws InterruptedException If the current thread was interrupted
* while waiting.
* @throws ExecutionException If the computation threw an exception.
*/
public final Result get() throws InterruptedException, ExecutionException {
return mFuture.get();
}
/**
* Waits if necessary for at most the given time for the computation
* to complete, and then retrieves its result.
*
* @param timeout Time to wait before cancelling the operation.
* @param unit The time unit for the timeout.
* @return The computed result.
* @throws InterruptedException If the current thread was interrupted
* while waiting.
* @throws ExecutionException If the computation threw an exception.
* @throws TimeoutException If the wait timed out.
*/
public final Result get(long timeout, TimeUnit unit) throws InterruptedException,
ExecutionException, TimeoutException {
return mFuture.get(timeout, unit);
}
/**
* execute方法返回自己(this),因此调用者可以保存它的引用
*
* 该方法可以在任何一个地方执行
*
* @param params The parameters of the task.
* @return This instance of UserTask.
* {@link UserTask.Status#RUNNING} or {@link UserTask.Status#FINISHED}.
*/
public final UserTask<Params, Progress, Result> execute(Params... params) {
if (mStatus != Status.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;
onTaskPrepare();
mWorker.mParams = params;
mExecutor.execute(mFuture);
return this;
}
/**
* This method can be invoked from {@link #onBackgroundExecute} to
* publish updates on the thread while the background computation is
* still running. Each call to this method will trigger the execution of
*
* @param values The progress values to update the result.
* {@link #onProgressUpdate}
* @see #onProgressUpdate
* @see #onBackgroundExecute
*/
public final void publishProgress(Progress... values) {
mHandler.obtainMessage(MESSAGE_POST_PROGRESS,
new UserTaskResult<Progress>(this, values)).sendToTarget();
}
/**
* Finish.
*
* @param result the result
*/
private void finish(Result result) {
if (isCancelled()) result = null;
onPostExecute(result);
mStatus = Status.FINISHED;
}
/**
* The Class InternalHandler.
*/
private static class InternalHandler extends Handler {
/* (non-Javadoc)
* @see android.os.Handler#handleMessage(android.os.Message)
*/
@SuppressWarnings({"unchecked", "RawUseOfParameterizedType"})
public void handleMessage(Message msg) {
UserTaskResult result = (UserTaskResult) 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;
case MESSAGE_POST_CANCEL:
result.mTask.onCancelled();
break;
}
}
}
/**
* The Class WorkerRunnable.
*
* @param <Params> the generic type
* @param <Result> the generic type
*/
private static abstract class WorkerRunnable<Params, Result> implements Callable<Result> {
/** The m params. */
Params[] mParams;
}
/**
* The Class UserTaskResult.
*
* @param <Data> the generic type
*/
@SuppressWarnings({"RawUseOfParameterizedType", "unchecked"})
private static class UserTaskResult<Data> {
/** The m task. */
final UserTask mTask;
/** The m data. */
final Data[] mData;
/**
* UserTaskResult的构造函数
*
* @param task the task
* @param data the data
*/
UserTaskResult(UserTask task, Data... data) {
mTask = task;
mData = data;
}
}
/**
* TaskCallback接口用于实现UserTask的registerCallback方法.
*
* @param <Params> the generic type
* @param <Progress> the generic type
* @param <Result> the generic type
*/
public interface TaskCallback<Params, Progress, Result> {
/**
* 耗时操作都放在在call方法里面
*
* @param task the task
* @return the result
* @throws AppException the app exception
*/
public Result call(UserTask<Params, Progress, Result> task, Params[] params) throws Exception;
}
}
//下面是一个使用该类的实例：
public class MainActivity extends Activity {
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
handlePrinter();
}
private void handlePrinter() {
final PrinterTask task = new PrinterTask(this);
task.registerCallback(new TaskCallback<Integer, Void, Integer>() {
@Override
public Integer call(UserTask<Integer, Void, Integer> task, Integer[] params)
throws Exception {
final int time = params[0];
android.util.Log.d("TAG", String.valueOf(time));
SystemClock.sleep(time);
return 0;
}
});
task.execute(5000);
}
private class PrinterTask extends UserTask<Integer, Void, Integer>{
public PrinterTask(Context context) {
super(context);
}
@Override
protected void onTaskPrepare() {
// TODO Auto-generated method stub
super.onTaskPrepare();
}
@Override
protected void onErrorHandle(Context context, Exception error) {
// TODO Auto-generated method stub
}
@Override
protected void onTaskFinished(Context context, Integer result) {
Toast.makeText(context, "5s", Toast.LENGTH_SHORT).show();
}
}
}
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- 面向过程就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了；面向对象是把构成问题事务分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描叙某个事物在整个解决问题的步骤中的行为(转)
- 使用AVAudioRecorder录音的时候模拟器可以录音但是真机不能录音的朋友来看看，这个方法可以解决你的问题哦
- 使用类的静态字段和构造函数，我们可以跟踪某个类所创建对象的个数。请写一个类，在任何时候都可以向它查询“你已经创建了多少个对象？”。
- 使用类的静态字段和构造函数，我们可以跟踪某个类所创建对象的个数。请写一个类，在任何时候都可以向它查询“你已经创建了多少个对象？”。
- Golang 中使用 JSON 的一些小技巧 陶文 陶文 3 个月前 有的时候上游传过来的字段是string类型的，但是我们却想用变成数字来使用。 本来用一个json:",string" 就可以支持了
- 在使用android studio过程中，使用gradle编译的时候总会出现一些问题，下面是几个常见问题的解决方法。
- 在进行C#编程时候，有的时候我们需要判断一个字符串是否是数字字符串，我们可以通过以下两种方法来实现。 【方法一】：使用 try{} catch{} 语句。 我们可以在try语句块中试图
- 使用类的静态字段和构造函数，我们可以跟踪某个类所创建对象的个数。请写一个类，在任何时候都可以向它查询“你已经创建了多少个对象？”。
- c#中跨线程调用windows窗体控件 .我们在做winform应用的时候，大部分情况下都会碰到使用多线程控制界面上控件信息的问题。然而我们并不能用传统方法来做这个问题，下面我将详细的介绍。
- 使用flask 发送电子邮件时候遇到的几个问题
- 有时候为了方便sql语句的对比和查询，我们可以使用declare来定义变量 上下篇的问题
- python默认的是17位小数的精度，但是这里有一个问题，就是当我们的计算需要使用更高的精度（超过17位小数）的时候该怎么做呢？
- 使用prototype.js 的时候应该特别注意的几个问题
- 使用prototype.js 的时候应该特别注意的几个问题.
- 在很多论坛上看到了有人抱怨Flash CS5中，代码提示(Code hint)有时不显示的问题，这个问题可能有很多原因，我整理了几个解决办法，有可能可以帮助到你～
- java中提供了对正则表达式的支持。 有的时候，恰当地使用正则，可以让我们的工作事半功倍！ 如下代码用来检验一个四则运算式中数据项的数目，请填写划线部分缺少的代码。 注意：只填写缺少代码，不要
- 一、 找出函数中存在的问题。以下题目均在Lab05项目中完成。2、 找出项目中存在的缺陷，并给出解决的方案（至少3个，不包含下面那个举例）。 说明：这里所说的缺陷不一定都是错误，而是明显需要改进的地方。 如：不可以无限输入密码，容易被暴力破解，存在安全隐患。
- 使用类的静态字段和构造函数，我们可以跟踪某个类所创建对象的个数。请写一个类，在任何时候都可以向它查询“你已经创建了多少个对象？”。
- 使用SSM的时候添加自定义的监听器(实现已知的那几个接口)出现报错的问题 推荐