AsycTask源码解读以及遇到的问题

最近项目有个需求，需要用户进来的时候异步传点东西，然后还不能让用户知道且不能影响正常接口的请求(偷偷地)。

于是我这样做了：
组装报文，通过AsycTask请求网络通讯，不处理返回结果；简单明了，想的很美！
结果：
在正常请求的接口请求时，一直显示菊花，等(偷偷的)请求的那些接口传完后，便可以了。
分析：
纳闷了，这不明明是异步请求吗，咋还能串起来了。
于是我就看起了源码；

//...前面省略
public abstract class AsyncTask<Params, Progress, Result> {
    private static final String LOG_TAG = "AsyncTask";
    private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
    //线程池的基本大小
    private static final int CORE_POOL_SIZE = CPU_COUNT + 1;
    //线程池核心容量(如使用无界的任务队列这个参数就没效果)
    private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;
    //过剩的空闲线程的存活时间  
    private static final int KEEP_ALIVE = 1;

    //ThreadFactory线程工厂,通过工厂方法newThread来获取新线程  
    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());
        }
    };
    //静态阻塞式队列,用来存放待执行的任务,初始容量:10个(系统原先是这样的，被我改成了下面的无界队列:无容量限制)  
    //  private static final BlockingQueue<Runnable> sPoolWorkQueue = new LinkedBlockingQueue<Runnable>(10); 
    // 修改为无界队列
    private static final BlockingQueue<Runnable> sPoolWorkQueue = new LinkedBlockingQueue<Runnable>();
    // 静态并发线程池(系统原先是这样的，被我改成了下面那样)
    // public static final Executor THREAD_POOL_EXECUTOR = new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE, TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory);
    // 增加相应的拒绝策略
    public static final Executor THREAD_POOL_EXECUTOR = new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE, TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory, new ThreadPoolExecutor.DiscardOldestPolicy());
    // 静态串行任务执行器
    public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
    // 消息类型:发送结果  
    private static final int MESSAGE_POST_RESULT = 0x1;
    // 消息类型:更新进度  
    private static final int MESSAGE_POST_PROGRESS = 0x2;
    /**
     * 静态Handler，用来发送上述两种通知，采用UI线程的Looper来处理消息 这就是为什           
     * 么AsyncTask必须在UI线程调用，因为子线程
     * 默认没有Looper无法创建下面的Handler，程序会直接Crash
     */
    private static final InternalHandler sHandler = new InternalHandler();
    //默认任务执行器,被赋值为串行任务执行器,就是它,AsyncTask变成串行的了  
    private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
    private final WorkerRunnable<Params, Result> mWorker;
    private final FutureTask<Result> mFuture;
    //后面省略...

其中有几个重要的地方
THREAD_POOL_EXECUTOR :并发线程池；
SERIAL_EXECUTOR :串行任务执行器,它只是把一个一个任务拿出来给并发线程池(THREAD_POOL_EXECUTOR)去执行；
sDefaultExecutor:默认任务执行器,给AsycTask添加默认的执行器,默认是串行的(SERIAL_EXECUTOR),想默认并发改成THREAD_POOL_EXECUTOR就ＯＫ了。

然后我就试着改成并行，如下：

//第一种方式：改成默认并行
private static volatile Executor sDefaultExecutor = THREAD_POOL_EXECUTOR;
//第二种方式：或者不用改源码就可以并行，在执行的之后这样调用
***.executeOnExecutor(UploadAsyncTask.THREAD_POOL_EXECUTOR);

运行几次，还是不行：
最后发现一处关键性代码

private static final BlockingQueue<Runnable> sPoolWorkQueue = new LinkedBlockingQueue<Runnable>(10)；

静态阻塞式队列,用来存放待执行的任务，采用链表的形式，遵循先进先出的原则。

原因正是阻塞造成，而我项目要求比较奇葩，在正常接口(a)前就已经开始了偷偷(b)传输，也就是b在a的前面先进去，导致a一直在后面等着，无奈之下只能暂时采取了一个笨办法，把AsycTask那个类再copy一个出来，b专门用的，这样a和b就不会在同一个队列，问题解决！

办法虽然欠佳，但暂时解决了需求，后续各位有什么好办法推荐下，多谢了。

第一次写博客，各位不喜请狂喷吧，对我可是有大大的好处，哈哈哈…