解决AsyncTask引发的RejectedExecutionException

 1         @Override
 2         public View getView(int pos, View view, ViewGroup viewGroup) {
 3             if (view == null) {
 4                 view = getLayoutInflater().inflate(R.layout.test2_list_item,
 5                         null);
 6             }
 7             ImageView imageView = (ImageView) view.findViewById(R.id.imageView);
 8             //这里每次都new出一个新的AsyncTask，进行执行。
 9             new TestAsyncTask(imageView, pos).execute(new Object());
10             TextView itemView = (TextView) view.findViewById(R.id.itemView);
11             itemView.setText("测试数据" + pos);
12             return view;
13         } 

 1 private class TestAsyncTask extends AsyncTask {
 2         private ImageView imageView;
 3         private int index;
 4 
 5         public TestAsyncTask(ImageView imageView, int index) {
 6             this.imageView = imageView;
 7             this.index = index;
 8         }
 9 
10         @Override
11         protected Object doInBackground(Object... arg0) {
12             // 模拟长时间的运算；大多数情况下是等待进行网络请求。
13             long sum = 0;
14             for (int i = 0; i <= 10000 * 100; i++) {
15                 sum += i * 1l;
16             }
17             return null;
18         }
19 
20         @Override
21         protected void onPostExecute(Object result) {
22             //模拟已经获得了网络请求的图片
23             imageView.setImageBitmap(BitmapFactory.decodeResource(
24                     getResources(), R.drawable.image01, null));
25         }
26     }

public class RejectedExecutionException
extends RuntimeException

Exception thrown by an Executor when a task cannot be accepted for execution.

Since:
1.5
See Also:
Serialized Form

 1     /**
 2      * Executes the task with the specified parameters. The task returns
 3      * itself (this) so that the caller can keep a reference to it.
 4      *
 5      * This method must be invoked on the UI thread.
 6      *
 7      * @param params The parameters of the task.
 8      *
 9      * @return This instance of AsyncTask.
10      *
11      * @throws IllegalStateException If {@link #getStatus()} returns either
12      *         {@link AsyncTask.Status#RUNNING} or {@link AsyncTask.Status#FINISHED}.
13      */
14     public final AsyncTask execute(Params... params) {
15         if (mStatus != Status.PENDING) {
16             switch (mStatus) {
17                 case RUNNING:
18                     throw new IllegalStateException("Cannot execute task:"
19                             + " the task is already running.");
20                 case FINISHED:
21                     throw new IllegalStateException("Cannot execute task:"
22                             + " the task has already been executed "
23                             + "(a task can be executed only once)");
24             }
25         }
26 
27         mStatus = Status.RUNNING;
28 
29         onPreExecute();
30 
31         mWorker.mParams = params;
32         sExecutor.execute(mFuture);
33 
34         return this;
35     }

 1     private static final String LOG_TAG = "AsyncTask";
 2 
 3     private static final int CORE_POOL_SIZE = 5;
 4     private static final int MAXIMUM_POOL_SIZE = 128;
 5     private static final int KEEP_ALIVE = 10;
 6 
 7     private static final BlockingQueue sWorkQueue =
 8             new LinkedBlockingQueue(10);
 9 
10     private static final ThreadFactory sThreadFactory = new ThreadFactory() {
11         private final AtomicInteger mCount = new AtomicInteger(1);
12 
13         public Thread newThread(Runnable r) {
14             return new Thread(r, "AsyncTask #" + mCount.getAndIncrement());
15         }
16     };
17 
18     private static final ThreadPoolExecutor sExecutor = new ThreadPoolExecutor(CORE_POOL_SIZE,
19             MAXIMUM_POOL_SIZE, KEEP_ALIVE, TimeUnit.SECONDS, sWorkQueue, sThreadFactory);

Rejected tasks
　New tasks submitted in method execute(Runnable) will be rejected when the Executor has been shut down, and also when the Executor uses finite bounds for both maximum threads and work queue capacity, and is saturated. In either case, the execute method invokes the rejectedExecution(Runnable, ThreadPoolExecutor) method of its         RejectedExecutionHandler. Four predefined handler policies are provided:

　　1.In the default ThreadPoolExecutor.AbortPolicy, the handler throws a runtime RejectedExecutionException upon rejection.
　　2.In ThreadPoolExecutor.CallerRunsPolicy, the thread that invokes execute itself runs the task. This provides a simple feedback control mechanism that will slow    down the rate that new tasks are submitted.
　　3.In ThreadPoolExecutor.DiscardPolicy, a task that cannot be executed is simply dropped.
　　4.In ThreadPoolExecutor.DiscardOldestPolicy, if the executor is not shut down, the task at the head of the work queue is dropped, and then execution is retried     (which can fail again, causing this to be repeated.)

It is possible to define and use other kinds of RejectedExecutionHandler classes. Doing so requires some care especially when policies are designed to work only under particular capacity or queuing policies.

1     private static final ThreadPoolExecutor sExecutor = new ThreadPoolExecutor(CORE_POOL_SIZE,
2             MAXIMUM_POOL_SIZE, KEEP_ALIVE, TimeUnit.SECONDS, sWorkQueue, sThreadFactory, new ThreadPoolExecutor.DiscardOldestPolicy());

    private static final String LOG_TAG = "AsyncTask";

    private static final int CORE_POOL_SIZE = 5;
    private static final int MAXIMUM_POOL_SIZE = 128;
    private static final int KEEP_ALIVE = 1;

    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 BlockingQueue sPoolWorkQueue =
            new LinkedBlockingQueue(10);

    /**
     * An {@link Executor} that can be used to execute tasks in parallel.
     */
    public static final Executor THREAD_POOL_EXECUTOR
            = new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE,
                    TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory);

    /**
     * An {@link Executor} that executes tasks one at a time in serial
     * order.  This serialization is global to a particular process.
     */
    public static final Executor SERIAL_EXECUTOR = new SerialExecutor();

    private static final int MESSAGE_POST_RESULT = 0x1;
    private static final int MESSAGE_POST_PROGRESS = 0x2;

    private static final InternalHandler sHandler = new InternalHandler();
    //这里我们发现到了这个默认的执行器，是下面实现的线性队列。
    private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
    private final WorkerRunnable mWorker;
    private final FutureTask mFuture;

    private volatile Status mStatus = Status.PENDING;
    
    private final AtomicBoolean mCancelled = new AtomicBoolean();
    private final AtomicBoolean mTaskInvoked = new AtomicBoolean();
    
    private static class SerialExecutor implements Executor {
        final ArrayDeque mTasks = new ArrayDeque();
        Runnable mActive;

        public synchronized void execute(final Runnable r) {
            mTasks.offer(new Runnable() {
                public void run() {
                    try {
                        r.run();
                    } finally {
                        scheduleNext();
                    }
                }
            });
            if (mActive == null) {
                scheduleNext();
            }
        }

        protected synchronized void scheduleNext() {
            if ((mActive = mTasks.poll()) != null) {
                THREAD_POOL_EXECUTOR.execute(mActive);
            }
        }
    }