Android异步消息常用汇总
android常用异步框架分为handler、AsyncTask、handlerThread、IntentService。
什么是handler
android消息机制的上层接口，通过发送和处理Message和Runnable对象来关联相对应线程的MessageQueue。
1. 可以让对应的Message和Runnable在未来的某个时间点进行相应的处理。
1. 让自己想要处理的耗时操作放在子线程，让更新ui放在主线程。
复制代码handler的使用方法
- post(runnable)
- sendMessage(msg)注意 msg的获取最好用Message.obtain()获取。底层采用对象池减少内存消耗。
handler机制原理
源码分析：
- 首先我们看下handler，MessageQueue，Looper是怎么关联在一起的？
public Handler(Callback callback, boolean async) {
if (FIND_POTENTIAL_LEAKS) {
final Class<? extends Handler> klass = getClass();
if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) &&
(klass.getModifiers() & Modifier.STATIC) == 0) {
Log.w(TAG, "The following Handler class should be static or leaks might occur: " +
klass.getCanonicalName());
}
}
mLooper = Looper.myLooper();
if (mLooper == null) {
throw new RuntimeException(
"Can't create handler inside thread that has not called Looper.prepare()");
}
mQueue = mLooper.mQueue;
mCallback = callback;
mAsynchronous = async;
}
复制代码在handler的构造方法中创建looper，然后根据looper的成员变量创建MessageQueue这样handler就和MessageQueue关联在了一起，而MessageQueue是通过Looper来管理的，从而三者关联在了一起; 我们点进去看下Looper.myLooper方法，发现是从sThreadLocal获取的，ThreadLocal是每个线程都独有的一份数据，所以每个handler获取的都对应自己线程的Looper。
public static @Nullable Looper myLooper() {
return sThreadLocal.get();
}
复制代码接着往下看发现sThreadLocal实在prepare（）中赋值的，这样保证了每个线程的唯一性。
private static void prepare(boolean quitAllowed) {
if (sThreadLocal.get() != null) {
throw new RuntimeException("Only one Looper may be created per thread");
}
sThreadLocal.set(new Looper(quitAllowed));
}
复制代码- 接着我们看下looper是怎么获取MessageQueue消息的。
public static void loop() {
...省略部分不重要代码
for (;;) {
Message msg = queue.next(); // might block
try {
msg.target.dispatchMessage(msg);
} msg.recycleUnchecked();
}
}
复制代码其实就是创建了一个for死循环，逐个取出msg，通过Handler（msg.target）dispatchMessage(msg)
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}
复制代码dispatchMessage，其实就是中转器，根据不同的条件不同的处理方式。
handler内存泄露及解决方案
非静态内部类持有外部类的引用，handler里面有可能里面有耗时或者延时操作，当activity销毁后由于handler持有activity，导致activity无法释放，造成了内存泄露。 解决方案：handler设置为静态内部类，在activity的onDestroy中调用handler.removeCallBack（）。注意如果在静态内部类中，如果要使用activity，一定用弱引用，而不是直接使用activity。
AsyncTask
AsyncTask可以用来处理一些后台较耗时的任务，查看源码发现其内部就是一个Handler和线程池的封装，可以帮助我们处理耗时任务的同时去更新UI。
AsyncTask的使用
- AsyncTask抽象类的3参数
public abstract class AsyncTask<Params, Progress, Result> {
......
}
Params 启动任务执行的输入参数，比如下载URL
Progress 后台任务执行的百分比，比如下载进度
Result 后台执行任务最终返回的结果，比如下载结果
复制代码- 子类可以实现的函数
onPreExecute():(运行在UI线程中) (非必须方法)
在任务执行前调用，通常用来做一些准备操作，比如下载文件前，在显示一个进度条等。
doInBackground(Params... params):(运行在子线程中)(必须实现)
可以在此方法中处理比较耗时的操作，比如下载文件等等。
onProgressUpdate(Progress... values) (运行在UI线程中) (非必须方法)
此函数异步任务执行时，回调给UI主线程的进度，比如上传或者下载进度。
onPostExecute(Result result)(运行在UI线程中) (非必须方法)
此函数代表任务执行结束了，回调给UI主线程的结果。比如下载结果。
onCancelled(Result result)onCancelled()任务关闭的函数
复制代码- 常用函数
cancel (boolean mayInterruptIfRunning)取消执行任务
execute (Params... params)用指定的参数来执行此任务
executeOnExecutor(Executor exec,Params... params)在指定的Executor中执行任务。
getStatus ()获得任务的当)前状态 PENDING(等待执行)、RUNNING(正在运行)、FINISHED(运行完成)
isCancelled ()在任务正常结束之前能成功取消任务则返回true，否则返回false
复制代码AsyncTask内部原理简介
AsyncTask注意事项
-
内存泄露 非静态内部类持有外部类的引用；如果Activity已经被销毁，AsyncTask的后台线程还在执行，它将继续在内存里保留这个引用，导致Activity无法被回收，引起内存泄露。 解决方案：把AsyncTask设置为静态内部类，里面持有activity的弱引用。并在onDestroy中cancel（）任务。
-
AsyncTask不与任何组件绑定生命周期 解决方案：在Activity/Fragment的onDestory()调用 cancel(true)；
-
串行或者并行的执行异步任务 当想要串行执行时，直接执行execute()方法，如果需要并行执行，则要执行executeOnExecutor(Executor)。建议串行，保证线程池的稳定，AsyncTask一般做不了高并发，太耗时的操作。
-
结果丢失 屏幕旋转或Activity在后台被系统杀掉等情况会导致Activity的重新创建，之前运行的AsyncTask会持有一个之前Activity的引用，这个引用已经无效，这时调用onPostExecute()再去更新界面将不再生效。
handlerThread
开启子线程进行耗时操作，多次创建和销毁线程是很消耗系统资源的，google为我们封装了handlerThread。它是有handler +thread +looper构成的。它是通过获取handlerThread的 looper对象传递给handler，然后在handleMessage执行异步任务。 优点是不会阻塞UI线程，缺点是串行执行，处理效率较低。
handlerThread使用
- 初始化HandlerThread然后调用其start方法
mHandlerThread = new HandlerThread("mHandlerThread");//这里的mHandlerThread其实就是线程的名字
mHandlerThread.start();
复制代码初始化Handler进行，传入mHandlerThread中的Looper，这样就保证了Handler运行在子线程，loop轮训，不同的交给handleMessage处理消息。
workHandler = new Handler(mHandlerThread.getLooper()) {
@Override
public void handleMessage(Message msg) {
...//消息处理
} }
};
复制代码3.使用工作线程Handler向工作线程的消息队列发送消息
Message msg = Message.obtain();
msg.what = 2; //消息的标识
msg.obj = "B"; // 消息的存放
// b. 通过Handler发送消息到其绑定的消息队列
workHandler.sendMessage(msg);
复制代码4.结束线程，即停止线程的消息循环 mHandlerThread.quit();
handlerThread源码分析
//1.Thread的子类
public class HandlerThread extends Thread {
int mPriority;
int mTid = -1;
Looper mLooper;
private @Nullable Handler mHandler;
//还记得上面的HandlerThread使用的初始化吗？
public HandlerThread(String name) {
super(name);
mPriority = Process.THREAD_PRIORITY_DEFAULT;
}
public HandlerThread(String name, int priority) {
super(name);
mPriority = priority;
}
//thread在开启start后会执行run方法，在这里会准备Looper并开启轮训。
@Override
public void run() {
mTid = Process.myTid();
Looper.prepare();
synchronized (this) {
mLooper = Looper.myLooper();
notifyAll();
}
Process.setThreadPriority(mPriority);
onLooperPrepared();
Looper.loop();
mTid = -1;
}
//还记得上面的Handler的创建吗？
public Looper getLooper() {
if (!isAlive()) {
return null;
}
synchronized (this) {
while (isAlive() && mLooper == null) {
try {
wait();
} catch (InterruptedException e) {
}
}
}
return mLooper;
}
//可以发送消息的异步Handler
@NonNull
public Handler getThreadHandler() {
if (mHandler == null) {
mHandler = new Handler(getLooper());
}
return mHandler;
}
public boolean quit() {
Looper looper = getLooper();
if (looper != null) {
looper.quit();
return true;
}
return false;
}
public boolean quitSafely() {
Looper looper = getLooper();
if (looper != null) {
looper.quitSafely();
return true;
}
return false;
}
public int getThreadId() {
return mTid;
}
}
复制代码注意点1：这里用了java线程知识，wait();和notifyAll()，为什么这么用呢 首先，Handler的创建一般是在主线程完成的，创建的时候获取HandlerThread.getLooper(),而Looper的创建是在子线程中创建的，这里就有线程同步问题了，比如我们调用getLooper()的时候HandlerThread中run()方法还没执行完，mLooper变量还未赋值，此时就执行了wait()等待逻辑，一直等到run()方法中mLooper被赋值，之后立即执行notifyAll()，然后getLooper()就可以正确返回mLooper了。 注意点2:quitSafely()和quit()有什么区别？
区别在于该方法移除消息、退出循环时是否在意当前队列是否正在处理消息，无论是否正在执行此时quit()都会立即退出该循环。 若是正在处理quitSafely，则等待该消息处理处理完毕再退出该循环。
IntentService
一个封装了HandlerThread和Handler的特殊Service，可以多次启动，每个耗时操作都会以工作队列的方式串行在IntentService的onHandleIntent回调方法中执行。任务执行完后会自动停止。
IntentService 使用
1.自定义LocalIntentService继承自IntentService
public class MyIntentService extends IntentService{
public LocalIntentService(String name) {
super(name);
}
}
复制代码2.实现onHandleIntent(), 是耗时操作。
@Override
protected void onHandleIntent(@Nullable Intent intent) {
String action = intent.getStringExtra("task_action");
//dosomething
}
复制代码IntentService 源码分析
- IntentService继承Service，首先我们看下onCreate()，可以看到里面创建了HandlerThread，所以可以耗时操作。
//IntentService第一次启动调用
public void onCreate() {
super.onCreate();
HandlerThread thread = new HandlerThread("IntentService[" + mName + "]");
thread.start();
mServiceLooper = thread.getLooper();
mServiceHandler = new ServiceHandler(mServiceLooper);
}
复制代码2.多次启动会走startService()->onStartCommand()->onStart()通过HandlerThread的handler去发送消息。
@Override
public int onStartCommand(@Nullable Intent intent, int flags, int startId) {
onStart(intent, startId);
return mRedelivery ? START_REDELIVER_INTENT : START_NOT_STICKY;
}
@Override
public void onStart(@Nullable Intent intent, int startId) {
Message msg = mServiceHandler.obtainMessage();
msg.arg1 = startId;
msg.obj = intent;
mServiceHandler.sendMessage(msg);
}
复制代码3.IntentService的SerivceHandler
HandlerThread顺序取出任务执行，会调用ServiceHandler的 handleMessage()->onHandleIntent()。任务执行完毕后stopSelf(startId)停止Service。任务结束后，在onDestory()中会退出HandlerThread中Looper的循环。
//ServiceHandler接收并处理onStart()方法中发送的Msg
private final class ServiceHandler extends Handler {
public ServiceHandler(Looper looper) {
super(looper);
}
@Override
public void handleMessage(Message msg) {
onHandleIntent((Intent)msg.obj);
stopSelf(msg.arg1); //会判断启动服务次数是否与startId相等
}
}
public void onDestroy() {
mServiceLooper.quit();
}
复制代码