android的定时及消息队列处理

  最近在做项目的时候，发觉有很多需要工作线程及消息处理的地方，而android自身提供了很好的包装类，这里对自己使用的一些梳理，权作自己的笔记。

主要有几种实现方式：

1.使用Handler.postAtTime定时将Runnable作为工作线程，处理耗时工作；

2.通过使用HandlerThread；

3.自定义Thread，并实现消息循环。

代码1：Runnable片段

	private Handler mTickerHandler = new Handler();
	private Runnable mTicker = new Runnable() {
		public void run() {
			if (mTickerStop) {
				return;
			}
			if (!mTickerSkip) {
				// TODO 执行实际的工作
			}
			long time = SystemClock.uptimeMillis();
			long step = time - time % 1000L + 1000L * STEP;
			// time - time % 1000L此处的减去求余操作，是为了将定时设置在整数秒上
			mTickerHandler.postAtTime(MainActivity.this.mTicker, step);
		}
	};

代码2：HandlerThread

	private final class ServiceHandler extends Handler {

		public ServiceHandler(Looper looper) {
			super(looper);
		}

		@Override
		public void handleMessage(Message msg) {
			int what = msg.what;
			trace("Thread:" + Thread.currentThread() + ", msg:" + msg);
			// 执行任务操作
		}
	}

	@Override
	public void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);

		// 此处定义了两个工作线程，并将工作线程并设置响应的消息处理的handler
		HandlerThread senderThread = new HandlerThread("[sender_service]");
		senderThread.start();
		mSenderServiceLooper = senderThread.getLooper();
		mSenderServiceHandler = new ServiceHandler(mSenderServiceLooper);

		HandlerThread receiverThread = new HandlerThread("[receiver_service]");
		receiverThread.start();
		mReceiverServiceLooper = receiverThread.getLooper();
		mReceiverServiceHandler = new ServiceHandler(mReceiverServiceLooper);
		
		// 开启定时处理
		startTicker();
	}

	@Override
	protected void onDestroy() {
		super.onDestroy();
		stopTicker(false);
		// 销毁时要调用quit方法，将工作线程的消息循环停止
		mSenderServiceLooper.quit();
		mReceiverServiceLooper.quit();
	}

代码3：Thread进行消息处理

	public Handler mExportHandler;
	private static final int _QUIT = -1;
	private static final int _STEP = 0;
	private static final int _START = 1;
	private static final int _END = 2;
	private static final int _FAIL = 3;

		new Thread() {
			private int preNext = 0;

			public void run() {
				Looper.prepare();

				mExportHandler = new Handler() {
					public void handleMessage(Message msg) {
						System.out.println("msg=" + msg);
						switch (msg.what) {
						case _QUIT:
							Looper.myLooper().quit();
							break;
						case _STEP:
							int next = exports(isSender, msg.arg1);
							if (next > 15) {
								mExportHandler.sendEmptyMessage(_QUIT);
								return;
							}
							if (preNext == next) {
								mExportHandler.sendMessageDelayed(
										mExportHandler.obtainMessage(_STEP,
												next, 0), 5000L);
							} else {
								preNext = next;
								mExportHandler.sendMessage(mExportHandler
										.obtainMessage(_STEP, next, 0));
							}
							break;
						case _START:
							break;
						case _END:
						case _FAIL:
							mReporter.report(
									ProcessReport.STATE_BACKUP_CONTACTS,
									msg.arg1, msg.arg2, msg.obj);
							break;
						}
					}
				};
				mExportHandler.sendMessage(mExportHandler.obtainMessage(_STEP,
						0, 0));
				Looper.loop();
			}
		}.start();

注意退出时发送mExportHandler.sendEmptyMessage(_QUIT);

因为项目中需要分步骤进行处理，在一个步骤上失败后需要进行间隔尝试

next > 15时作退出处理，15只是一个步骤定义，可以指定更多或更少。

	private int exports(boolean isSender, int step) {
		int next = step;
		try {
			if (next == 0) {
				// 步骤一
				if (!excutore(...)) {
					// 失败时next保持不变，直接放回，定时间隔后再次执行
					return next;
				}
				// 执行成功后，进行下一步操作
				next++;
			}
			if (next == 1) {
				// 步骤二
				if (!excutore(...)) {
					// 失败时next保持不变，直接放回，定时间隔后再次执行
					return next;
				}
			}

			// 其他步骤依此
			...
			
			// > 15则退出循环
			next = 16;
		} catch (Exception e) {
			AdbDebug.LogException(e);
		}
		return next;
	}

代码1、2的完整代码

import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.os.HandlerThread;
import android.os.Looper;
import android.os.Message;
import android.os.SystemClock;

public class MainActivity extends Activity {

	private static final boolean DEBUG = false;
	private static final long STEP = 15L;

	private boolean mTickerStop = true;
	private boolean mTickerSkip;
	private volatile Looper mSenderServiceLooper;
	private volatile Looper mReceiverServiceLooper;
	private volatile ServiceHandler mSenderServiceHandler;
	private volatile ServiceHandler mReceiverServiceHandler;

	private Handler mTickerHandler = new Handler();
	private Runnable mTicker = new Runnable() {
		public void run() {
			if (mTickerStop) {
				return;
			}
			if (!mTickerSkip) {
				// TODO 执行实际的工作
			}
			long time = SystemClock.uptimeMillis();
			long step = time - time % 1000L + 1000L * STEP;
			// time - time % 1000L此处的减去求余操作，是为了将定时设置在整数秒上
			mTickerHandler.postAtTime(MainActivity.this.mTicker, step);
		}
	};

	private final class ServiceHandler extends Handler {

		public ServiceHandler(Looper looper) {
			super(looper);
		}

		@Override
		public void handleMessage(Message msg) {
			int what = msg.what;
			trace("Thread:" + Thread.currentThread() + ", msg:" + msg);
			// 执行任务操作
		}
	}

	@Override
	public void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);

		// 此处定义了两个工作线程，并将工作线程并设置响应的消息处理的handler
		HandlerThread senderThread = new HandlerThread("[sender_service]");
		senderThread.start();
		mSenderServiceLooper = senderThread.getLooper();
		mSenderServiceHandler = new ServiceHandler(mSenderServiceLooper);

		HandlerThread receiverThread = new HandlerThread("[receiver_service]");
		receiverThread.start();
		mReceiverServiceLooper = receiverThread.getLooper();
		mReceiverServiceHandler = new ServiceHandler(mReceiverServiceLooper);
		
		// 开启定时处理
		startTicker();
	}

	@Override
	protected void onDestroy() {
		super.onDestroy();
		stopTicker(false);
		// 销毁时要调用quit方法，将工作线程的消息循环停止
		mSenderServiceLooper.quit();
		mReceiverServiceLooper.quit();
	}

	private void startTicker() {
		mTickerSkip = false;
		if (mTickerStop) {
			mTickerStop = false;
			mTicker.run();
		}
	}

	private void stopTicker(boolean isStop) {
		if (isStop && !mTickerStop) {
			// 当前没有停止时，则移除消息队列中的消息，并将mTickerStop赋值true
			mTickerHandler.removeCallbacks(mTicker);
			mTickerStop = true;
		}
		mTickerSkip = true;
	}
}