一、自定义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() {
}
@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) {
}
}
3、执行任务。
LoadParams parasm = new LoadParams();
new LoadDataTask().excute(params);