(this, result));
273 | message.sendToTarget();
274 | return result;
275 | }
276 |
277 | /**
278 | * Returns the current status of this task.
279 | *
280 | * @return The current status.
281 | */
282 | public final Status getStatus() {
283 | return mStatus;
284 | }
285 |
286 | /**
287 | * Override this method to perform a computation on a background thread. The
288 | * specified parameters are the parameters passed to {@link #execute}
289 | * by the caller of this task.
290 | *
291 | * This method can call {@link #publishProgress} to publish updates
292 | * on the UI thread.
293 | *
294 | * @param params The parameters of the task.
295 | *
296 | * @return A result, defined by the subclass of this task.
297 | *
298 | * @see #onPreExecute()
299 | * @see #onPostExecute
300 | * @see #publishProgress
301 | */
302 | protected abstract Result doInBackground(Params... params);
303 |
304 | /**
305 | * Runs on the UI thread before {@link #doInBackground}.
306 | *
307 | * @see #onPostExecute
308 | * @see #doInBackground
309 | */
310 | protected void onPreExecute() {}
311 |
312 | /**
313 | * Runs on the UI thread after {@link #doInBackground}. The
314 | * specified result is the value returned by {@link #doInBackground}.
315 | *
316 | * This method won't be invoked if the task was cancelled.
317 | *
318 | * @param result The result of the operation computed by {@link #doInBackground}.
319 | *
320 | * @see #onPreExecute
321 | * @see #doInBackground
322 | * @see #onCancelled(Object)
323 | */
324 | @SuppressWarnings({"UnusedDeclaration"})
325 | protected void onPostExecute(Result result) {}
326 |
327 | /**
328 | * Runs on the UI thread after {@link #publishProgress} is invoked.
329 | * The specified values are the values passed to {@link #publishProgress}.
330 | *
331 | * @param values The values indicating progress.
332 | *
333 | * @see #publishProgress
334 | * @see #doInBackground
335 | */
336 | @SuppressWarnings({"UnusedDeclaration"})
337 | protected void onProgressUpdate(Progress... values) {}
338 |
339 | /**
340 | * Runs on the UI thread after {@link #cancel(boolean)} is invoked and
341 | * {@link #doInBackground(Object[])} has finished.
342 | *
343 | * The default implementation simply invokes {@link #onCancelled()} and
344 | * ignores the result. If you write your own implementation, do not call
345 | * super.onCancelled(result).
346 | *
347 | * @param result The result, if any, computed in
348 | * {@link #doInBackground(Object[])}, can be null
349 | *
350 | * @see #cancel(boolean)
351 | * @see #isCancelled()
352 | */
353 | @SuppressWarnings({"UnusedParameters"})
354 | protected void onCancelled(Result result) {
355 | onCancelled();
356 | }
357 |
358 | /**
359 | * Applications should preferably override {@link #onCancelled(Object)}.
360 | * This method is invoked by the default implementation of
361 | * {@link #onCancelled(Object)}.
362 | *
363 | * Runs on the UI thread after {@link #cancel(boolean)} is invoked and
364 | * {@link #doInBackground(Object[])} has finished.
365 | *
366 | * @see #onCancelled(Object)
367 | * @see #cancel(boolean)
368 | * @see #isCancelled()
369 | */
370 | protected void onCancelled() {}
371 |
372 | /**
373 | * Returns true if this task was cancelled before it completed
374 | * normally. If you are calling {@link #cancel(boolean)} on the task,
375 | * the value returned by this method should be checked periodically from
376 | * {@link #doInBackground(Object[])} to end the task as soon as possible.
377 | *
378 | * @return true if task was cancelled before it completed
379 | *
380 | * @see #cancel(boolean)
381 | */
382 | public final boolean isCancelled() {
383 | return mCancelled.get();
384 | }
385 |
386 | /**
387 | * Attempts to cancel execution of this task. This attempt will
388 | * fail if the task has already completed, already been cancelled,
389 | * or could not be cancelled for some other reason. If successful,
390 | * and this task has not started when cancel is called,
391 | * this task should never run. If the task has already started,
392 | * then the mayInterruptIfRunning parameter determines
393 | * whether the thread executing this task should be interrupted in
394 | * an attempt to stop the task.
395 | *
396 | * Calling this method will result in {@link #onCancelled(Object)} being
397 | * invoked on the UI thread after {@link #doInBackground(Object[])}
398 | * returns. Calling this method guarantees that {@link #onPostExecute(Object)}
399 | * is never invoked. After invoking this method, you should check the
400 | * value returned by {@link #isCancelled()} periodically from
401 | * {@link #doInBackground(Object[])} to finish the task as early as
402 | * possible.
403 | *
404 | * @param mayInterruptIfRunning true if the thread executing this
405 | * task should be interrupted; otherwise, in-progress tasks are allowed
406 | * to complete.
407 | *
408 | * @return false if the task could not be cancelled,
409 | * typically because it has already completed normally;
410 | * true otherwise
411 | *
412 | * @see #isCancelled()
413 | * @see #onCancelled(Object)
414 | */
415 | public final boolean cancel(boolean mayInterruptIfRunning) {
416 | mCancelled.set(true);
417 | return mFuture.cancel(mayInterruptIfRunning);
418 | }
419 |
420 | /**
421 | * Waits if necessary for the computation to complete, and then
422 | * retrieves its result.
423 | *
424 | * @return The computed result.
425 | *
426 | * @throws CancellationException If the computation was cancelled.
427 | * @throws ExecutionException If the computation threw an exception.
428 | * @throws InterruptedException If the current thread was interrupted
429 | * while waiting.
430 | */
431 | public final Result get() throws InterruptedException, ExecutionException {
432 | return mFuture.get();
433 | }
434 |
435 | /**
436 | * Waits if necessary for at most the given time for the computation
437 | * to complete, and then retrieves its result.
438 | *
439 | * @param timeout Time to wait before cancelling the operation.
440 | * @param unit The time unit for the timeout.
441 | *
442 | * @return The computed result.
443 | *
444 | * @throws CancellationException If the computation was cancelled.
445 | * @throws ExecutionException If the computation threw an exception.
446 | * @throws InterruptedException If the current thread was interrupted
447 | * while waiting.
448 | * @throws TimeoutException If the wait timed out.
449 | */
450 | public final Result get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException,
451 | TimeoutException {
452 | return mFuture.get(timeout, unit);
453 | }
454 |
455 | /**
456 | * Executes the task with the specified parameters. The task returns
457 | * itself (this) so that the caller can keep a reference to it.
458 | *
459 | * Execute a task immediately.
460 | *
461 | *
This method must be invoked on the UI thread.
462 | *
463 | *
用于重要、紧急、单独的异步任务，该Task立即得到执行。
464 | *
加载类似瀑布流时产生的大量并发（一定程度允许任务被剔除队列）时请用{@link AsyncTask#executeAllowingLoss(Object...)}
465 | * @param params The parameters of the task.
466 | *
467 | * @return This instance of AsyncTask.
468 | *
469 | * @throws IllegalStateException If {@link #getStatus()} returns either
470 | * {@link AsyncTask.Status#RUNNING} or {@link AsyncTask.Status#FINISHED}.
471 | *
472 | * @see #executeOnExecutor(java.util.concurrent.Executor, Object[])
473 | * @see #execute(Runnable)
474 | */
475 | public final AsyncTask execute(final Params... params) {
476 | return executeOnExecutor(sDefaultExecutor, params);
477 | }
478 |
479 | /**
480 | * 用于瞬间大量并发的场景，比如，假设用户拖动{@link ListView}时如果需要加载大量图片，而拖动过去时间很久的用户已经看不到，允许任务丢失。
481 | *
This method execute task wisely when a large number of task will be submitted.
482 | * @param params
483 | * @return
484 | */
485 | public final AsyncTask executeAllowingLoss(Params... params) {
486 | return executeOnExecutor(mLruSerialExecutor, params);
487 | }
488 |
489 | /**
490 | * Executes the task with the specified parameters. The task returns
491 | * itself (this) so that the caller can keep a reference to it.
492 | *
493 | * This method is typically used with {@link #mCachedSerialExecutor} to
494 | * allow multiple tasks to run in parallel on a pool of threads managed by
495 | * AsyncTask, however you can also use your own {@link Executor} for custom
496 | * behavior.
497 | *
498 | *
This method must be invoked on the UI thread.
499 | *
500 | * @param exec The executor to use. {@link #mCachedSerialExecutor} is available as a
501 | * convenient process-wide thread pool for tasks that are loosely coupled.
502 | * @param params The parameters of the task.
503 | *
504 | * @return This instance of AsyncTask.
505 | *
506 | * @throws IllegalStateException If {@link #getStatus()} returns either
507 | * {@link AsyncTask.Status#RUNNING} or {@link AsyncTask.Status#FINISHED}.
508 | *
509 | * @see #execute(Object[])
510 | */
511 | public final AsyncTask executeOnExecutor(Executor exec, Params... params) {
512 | if (mStatus != Status.PENDING) {
513 | switch (mStatus) {
514 | case RUNNING :
515 | throw new IllegalStateException("Cannot execute task:" + " the task is already running.");
516 | case FINISHED :
517 | throw new IllegalStateException("Cannot execute task:" + " the task has already been executed "
518 | + "(a task can be executed only once)");
519 | }
520 | }
521 |
522 | mStatus = Status.RUNNING;
523 |
524 | onPreExecute();
525 |
526 | mWorker.mParams = params;
527 | exec.execute(mFuture);
528 |
529 | return this;
530 | }
531 |
532 | /**
533 | * Convenience version of {@link #execute(Object...)} for use with
534 | * a simple Runnable object. See {@link #execute(Object[])} for more
535 | * information on the order of execution.
536 | * 用于重要、紧急、单独的异步任务，该Runnable立即得到执行。
537 | *
加载类似瀑布流时产生的大量并发（任务数超出限制允许任务被剔除队列）时请用{@link AsyncTask#executeAllowingLoss(Runnable)}
538 | * @see #execute(Object[])
539 | * @see #executeOnExecutor(java.util.concurrent.Executor, Object[])
540 | */
541 | public static void execute(Runnable runnable) {
542 | sDefaultExecutor.execute(runnable);
543 | }
544 |
545 | /**
546 | *
用于瞬间大量并发的场景，比如，假设用户拖动{@link ListView}时如果需要启动大量异步线程，而拖动过去时间很久的用户已经看不到，允许任务丢失。
547 | *
This method execute runnable wisely when a large number of task will be submitted.
548 | *
任务数限制情况见{@link SmartSerialExecutor}
549 | * immediate execution for important or urgent task.
550 | * @param runnable
551 | */
552 | public static void executeAllowingLoss(Runnable runnable) {
553 | mLruSerialExecutor.execute(runnable);
554 | }
555 |
556 | /**
557 | * This method can be invoked from {@link #doInBackground} to
558 | * publish updates on the UI thread while the background computation is
559 | * still running. Each call to this method will trigger the execution of
560 | * {@link #onProgressUpdate} on the UI thread.
561 | *
562 | * {@link #onProgressUpdate} will note be called if the task has been
563 | * canceled.
564 | *
565 | * @param values The progress values to update the UI with.
566 | *
567 | * @see #onProgressUpdate
568 | * @see #doInBackground
569 | */
570 | protected final void publishProgress(Progress... values) {
571 | if (!isCancelled()) {
572 | sHandler.obtainMessage(MESSAGE_POST_PROGRESS, new AsyncTaskResult