android 简易异步任务工具

众所周知，android 是不允许在主线程（UI线程）上执行耗时操作的，这样导致界面卡顿，影响用户体验

如果你尝试在主线程执行网络请求，android 会给你抛出异常

当然 android 官方也有一些解决方案，比如 Loader AsyncTask ，不过在我看来就是跟渣一样，学习成本高，难以理解，我记得我最初研究者东西花了老半天精力，后来随着代码的积累，对以移动开发也有了自己的体会，于是自己写了一个操作类

这个类，使用 Thread + HandlerThread 实现，异步执行，任务在自创线程，回调在主线程， 重复使用，

import android.os.Handler;
import android.os.Handler.Callback;
import android.os.HandlerThread;
import android.os.Looper;
import android.os.Message;

/**
 * 一条工作线程，可以用来执行网络等耗时操作
 * 
 * @author Yichou 2015-11-18
 *
 */
public final class WorkThread implements Callback {
	public static final Logger log = Logger.create("WorkThread");
	private HandlerThread mThread;
	private Handler mHandler;
	
	private static final Handler mUiHandler = new Handler(Looper.getMainLooper());
	
	
	public WorkThread() {
		this("WorkThread");
	}
	
	public WorkThread(String name) {
		mThread = new HandlerThread(name);
		mThread.start();
		mHandler = new Handler(mThread.getLooper(), this);
		mHandler.sendEmptyMessage(0);
	}
	
	@Override
	public boolean handleMessage(Message msg) {
		switch (msg.what) {
		case 0:
			log.i("Hello I am worker, just give me a task.");
			break;
		
		default:
			return false;
		}

		return true;
	}
	
	/**
	 * 任务完成回调，UI线程
	 * 
	 * @author Jainbin
	 *
	 */
	public interface IFinishCallback {
		public void onFinish(Object result);
	}

	/**
	 * 执行任务回调，任务线程
	 * 
	 * @author Jainbin
	 *
	 */
	public interface IDoCallback {
		public abstract Object onDo(Object doParam);
	}
	
	private class FinishRunable implements Runnable {
		private Object mData;
		private IFinishCallback mCallback;
		
		
		private FinishRunable(IFinishCallback cb, Object data) {
			mCallback = cb;
			mData = data;
		}
		
		@Override
		public void run() {
			mCallback.onFinish(mData);
		}
	}
	
	private class DoRunable implements Runnable {
		private IDoCallback mDoCallback;
		private IFinishCallback mFinishCallback;
		private Object mDoData;

		
		private DoRunable(IDoCallback cb, Object data, IFinishCallback cb2) {
			mDoCallback = cb;
			mDoData = data;
			mFinishCallback = cb2;
		}

		@Override
		public void run() {
			Object ret = mDoCallback.onDo(mDoData);
			mUiHandler.post(new FinishRunable(mFinishCallback, ret));
		}
	}
	
	public void postCb(IDoCallback cb, Object doData, IFinishCallback cb2) {
		mHandler.post(new DoRunable(cb, doData, cb2));
	}
	
	private class IRunable implements Runnable {
		Runnable taskRunnable;
		Runnable callbackRunnable;
		
		public IRunable(Runnable task, Runnable callback) {
			this.taskRunnable = task;
			this.callbackRunnable = callback;
		}
		
		@Override
		public void run() {
			taskRunnable.run();
			mUiHandler.post(callbackRunnable);
		}
	}
	
	public void postDelay(Runnable r, long delayMillis) {
		mHandler.postDelayed(r, delayMillis);
	}
	
	/**
	 * 发送一个带回调的任务
	 * 
	 * @param task 主任务，在 sdk 线程执行
	 * @param callback 回调器，主任务在 sdk 线程执行完毕后，在UI线程调此回调
	 */
	public void postEx(Runnable task, Runnable callback) {
		mHandler.post(new IRunable(task, callback));
	}
	
	public interface ITask {
		/**
		 * 执行回调，在任务线程
		 * 
		 * @param args 参数
		 * 
		 * @return 执行结果，作为 {@link #onResult(Object)} 参数
		 */
		public Object onDo(Object... args);
		
		/**
		 * 任务完成回调，在 UI 线程
		 * 
		 * @param ret {@link #onDo(Object...)} 的返回值
		 */
		public void onResult(Object ret);
	}
	
//	public static class CommonTask implements ITask {
//		private ProgressDialog mDialog;
//
//		public CommonTask showDialog(Activity activity, String msg) {
//			mDialog = new Prgre
//			dialog = Common.createLoadingDialog(activity);
//	        dialog.show();
//	        return this;
//	    }
//		
//		@Override
//		public Object onDo(Object... args) {
//			// TODO Auto-generated method stub
//			return null;
//		}
//
//		@Override
//		public void onResult(Object ret) {
//			// TODO Auto-generated method stub
//			
//		}
//		
//	}
	
	private class ITaskRunable implements Runnable {
		private ITask mTask;
		private Object[] mArgs;
		private Object mRet;
		
		private ITaskRunable(ITask task, Object... args) {
			this.mTask = task;
			this.mArgs = args;
		}

		@Override
		public void run() {
			mRet = mTask.onDo(mArgs);
			mUiHandler.post(new Runnable() {
				
				@Override
				public void run() {
					mTask.onResult(mRet);
				}
			});
		}
	}
	
	/**
	 * 2016-1-5 by yichou
	 * 
	 * @param task 任务回调器
	 * @param args 参数
	 */
	public void postTask(ITask task, Object... args) {
		mHandler.post(new ITaskRunable(task, args));
	}

	public void postTask(ITask task) {
		mHandler.post(new ITaskRunable(task, (Object[])null));
	}
	
	public void postTaskDelay(int t, ITask task) {
		mHandler.postDelayed(new ITaskRunable(task, (Object[])null), t);
	}
	
	public void post(Runnable r) {
		mHandler.post(r);
	}
	
	/**
	 * 发送一个任务到UI线程
	 * 
	 * @param r 任务
	 */
	public void postToUiThread(Runnable r) {
		mUiHandler.post(r);
	}
	
	public Handler getHandler() {
		return mHandler;
	}
	
	public Handler getUiHandler() {
		return mUiHandler;
	}
	
	public void init() {
	}
	
	public void exit() {
		mThread.quit();
		try {
			mThread.join(3000);
		} catch (InterruptedException e) {
		}
		log.i("join finish!");
		log.d("exited");
	}
	
	private static final Singleton<WorkThread> gDefault = new Singleton<WorkThread>() {

		@Override
		protected WorkThread create() {
			return new WorkThread();
		}
	};
	
	public static WorkThread getDefault() {
		return gDefault.get();
	}
}

调用实例：

	void showIp() {
		WorkThread.getDefault().postTask(new WorkThread.ITask() {
			
			@Override
			public void onResult(Object ret) {
				new AlertDialog.Builder(getActivity())
					.setTitle("IP信息").setMessage("" + ret)
					.setPositiveButton(R.string.ok, null)
					.create().show();
			}
			
			@Override
			public Object onDo(Object... args) {
				return IpUtil.getIpInfoFrom138();
			}
		});
	}