9、实现自定义AsyncTask

一、自定义AsyncTask。

package com.example.asynctask;

import java.util.ArrayDeque;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.Callable;
import java.util.concurrent.CancellationException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executor;
import java.util.concurrent.FutureTask;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;

import android.os.Handler;
import android.os.Looper;
import android.text.TextUtils;

public abstract class CustomAsyncTask<Params, T, Result> {

public static class AsyncTaskBaseParam {
    public int operation;
}

ThreadPoolExecutor mThreadPoolExecutor;

BlockingQueue<Runnable> mBlockingQueue;

AtomicBoolean mTaskCancel;

Handler mUIHandler;

Executor mExecutor;

private String mThreadName;

public CustomAsyncTask() {
    this(1, false);
}

public CustomAsyncTask(int threadCount, boolean isSerial) {
    this(1,threadCount, isSerial, null);
}

public CustomAsyncTask(int coreThreadCount, int maxThreadCount, boolean isSerial, String poolName) {
    if (TextUtils.isEmpty(poolName)) {
        mThreadName = getClass().getSimpleName();
    } else {
        mThreadName = poolName;
    }
    mUIHandler = new Handler(Looper.getMainLooper());
    mBlockingQueue = new LinkedBlockingQueue<Runnable>();
    mThreadPoolExecutor = new ThreadPoolExecutor(coreThreadCount, maxThreadCount, 1, TimeUnit.SECONDS,     mBlockingQueue,
    new CustomThreadFactory(mThreadName)); 
    mThreadPoolExecutor.allowCoreThreadTimeOut(true);
    if (isSerial) {
        mExecutor = new SerialExecutor(mThreadPoolExecutor);
    } else {
        mExecutor = mThreadPoolExecutor;
    }
}

public CustomAsyncTask<Params, T, Result> execute(Params... params) { 
    onPreExecute();
    mExecutor.execute(new FutureTask<Result>(new WorkerRunnable(params)) {
        @Override
        protected void done() {
            super.done();
            try {
                postResult(get());
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                throw new RuntimeException("An error occured while executing CustomAsyncTask doInBackground()",
                e.getCause());
            } catch (CancellationException e) {
        }
    }

    });
    return this;
 }

protected Result postResult(final Result result) {
    mUIHandler.post(new Runnable() {
        @Override
        public void run() {
            onPostExecute(result);
        }
    });
    return result;
}

protected void onPreExecute() {

}

protected abstract Result doInBackground(Params...params);

protected void onPostExecute(Result r) {

}

class WorkerRunnable implements Callable<Result> {

    WorkerRunnable(Params... p) {
        mParams = p;
    }

    Params[] mParams;

    @Override
    public Result call() throws Exception {
        android.os.Process.setThreadPriority(android.os.Process.THREAD_PRIORITY_BACKGROUND);
        final Result r = doInBackground(mParams);
        return r;
    }
}

static class CustomThreadFactory implements ThreadFactory {

    private String mThreadNamePattern;
    private int mThreadOrder;
    public CustomThreadFactory(String name) {
        mThreadNamePattern = name;
        mThreadOrder = 0;
    }

@Override
public Thread newThread(Runnable runnable) {

    Thread thread = new Thread(runnable, makeName());

    thread.setPriority(Thread.MIN_PRIORITY);

    return thread;
    }

    String makeName() {
    StringBuilder sb = new StringBuilder();

    sb.append(mThreadNamePattern);
    sb.append(" ").append(mThreadOrder++);

    return sb.toString();
    }
}

static class SerialExecutor implements Executor {

    final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();
    Runnable mActive;
    Executor mRealExecutor;

    SerialExecutor(Executor realExecutor) {
        mRealExecutor = realExecutor;
    }

    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) {
                if (mRealExecutor != null) {
                    mRealExecutor.execute(mActive);
                }
            }     
        }
    }
}

二、使用AsyncTask。

1、定义LoadParams,ResultParams。

class LoadParams {
    int op;
    ...
}

class ResultParams {
     int op;
}

2、定义一个类继承CustomAsyncTask。

private class LoadDataTask extend CustomAsyncTask<LoadParams, Void, ResultParams> {
     @Override 
     protected void onPreExecute() {
          //主线程，在DoinBackGround之前执行。
     }
     @Override
     protected ResultParamsdoInBackground(LoadParams... params) {
         LoadParams loadParams = params[0];
         ResultParams result = new ResultParams();
          int op = loadParams .op;
          switch(op) {
              case xx:
                   break;
             case xx:
                   break;
         }
          return result ;
      }
     @Override
    protected void onPostExecute(Boolean result) {
    //主线程，在DoinBackGround之后执行
     }
}

3、执行任务。

LoadParams parasm = new LoadParams();
new LoadDataTask().excute(params);