盘点 Handler 的经典十几连问
作者：阿河
1. 说说对Handler 的理解
//\frameworks\base\core\java\android\os\Handler.java
//\frameworks\base\core\java\android\os\Looper.java
//\frameworks\base\core\java\android\os\Message.java
//\frameworks\base\core\java\android\os\MessageQueue.java
-
Android Handler 是一套 异步消息传递机制（异步通信机制）。主要适用于同一个组件（或者说是同一个文件中）不同线程之间的信息传递。
-
有时候需要在子线程中进行耗时的 IO 操作，这可能是读取文件或者访问网络等，当耗时操作完成以后可能需要在 UI上做一些改变，由于 Android 开发规范的限制，我们并不能在子线程中访问 UI 控件，否则就会触发程序异常，这个时候通过 Handler 就可以将更新 UI 的操作切换到主线程中执行。
-
Handler机制 由Handler，Message，MessageQueue和Looper四个组件组成
Message 是线程之间传递的信息，它可以在内部携带少量的信息，用于在不同线程之间交换数据；
Handler 顾名思义也就是处理者的意思，它主要是用于发送和处理消息的。发送消息一般是使用 Handler.sendMessage()，而发出的消息经过一系列地辗转处理后，最终会传递到Handler.handleMessage()；
MessageQueue 是消息队列的意思，它主要用于存放所有通过 Handler 发送的消息。这部分消息会一直存在于消息队列中，等待被处理，其本质上是一个按时间排序的单向链表；
Looper 是每个线程中的 MessageQueue 的管家，调用 Looper 的 loop() 方法后，就会进入到一个无限循环当中，然后每当发现 MessageQueue 中存在一条消息，就会将它取出，并传递到 Handler.handleMessage() 方法中。
- Handler的使用方法
* This is a typical example of the implementation of a Looper thread,
* using the separation of {@link #prepare} and {@link #loop} to create an
* initial Handler to communicate with the Looper.
*
*
* class LooperThread extends Thread {
* public Handler mHandler;
*
* public void run() {
* Looper.prepare();
*
* mHandler = new Handler(Looper.myLooper()) {
* public void handleMessage(Message msg) {
* // process incoming messages here
* }
* };
*
* Looper.loop();
* }
* }
*/
自己对Handler机制使用的理解：
a. Looper.prepare() 本质是去创建Looper, 而创建Looper的核心要义就是创建一个MessageQueue。可以将Looper看成是流水线的引擎，而MessageQueue就是流水线皮带上的托盘；
public static void prepare() {
prepare(true);
}
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) );
}
private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed) ;
mThread = Thread.currentThread();
}
b. new Handler(Looper.myLooper())就是告诉Handler(工人)该去处理哪条流水线的活儿，Handler.sendMessage() 就是让Handler(工人)往流水线皮带上的托盘放需要处理的零件(message)，而Handler.dispatchMessage() 就是将流水线末端的托盘上的零件(message)取出来处理；
c. Looper.loop() 就是启动流水线引擎Looper，让流水线运转起来；
a. 传送带上的零件（Message）是先进先出的。每次工人往传送带（MessageQueue）上的托盘放零件（Message）时，会考虑下哪个零件需要处理的优先级，按照需要处理的优先级排序放入到传送带MessageQueue中;
b. 每次工人(Handler)处理完零件(message)后，会将托盘收集起来扔进托盘堆里(sPool)，这个托盘堆最多能放50个，然后后面工人需要放零件使用托盘的时候，直接从这里面拿就可以了，节省时间；
c. 当流水线皮带上的托盘里面的零件(message)还没有到达需要处理的时间时，Looper会停止传送，进入待机状态；
d. 一条完整的流水线只有一个引擎（Looper）和一条传送带（MessageQueue），而工人（Handler）可以有多个。工人在往传送带上放置零件（Message）的时候，会在上面添加工人(Handler)的个人信息（msg.target），然后再流水线终端处理的工人会根据这个（msg.target）将其派发给指定的工人处理(dispatchMessage(msg));
e. 当传送带上（MessageQueue）中没有零件（Message）时，引擎（Looper）不再运转进入待机状态，整个系统阻塞在准备取下一个零件的状态中（MessageQueue.next()）,实际上是调用的nativePollOnce 的底层方法，一旦传送带上又有了新的零件（Message），流水线系统就会继续运转；
2. 一个线程有几个Looper？有几个messageQueue？如何保证？
一个线程只有一个 Looper对象和一个 MessageQueue 对象。
在创建 Handler 之前，需要调用 Looper.prepare() ，该函数保证了每个线程只有一个 Looper 对象。
/** Initialize the current thread as a looper.
* This gives you a chance to create handlers that then reference
* this looper, before actually starting the loop. Be sure to call
* {@link #loop()} after calling this method, and end it by calling
* {@link #quit()}.
*/
public static void prepare() {
prepare(true);
}
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));
}
而 MessageQueue 又是在 Looper 的构造函数中创建的，保证了一个 Looper 对应一个 MessageQueue
private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}
3. 一个线程可以有几个handler？那如何保证message能分配给正确的handler 处理呢？
因为Handler可以在Activity里new，在Service里面也可以new，而Activity全部都跑在了主线程里面，这就证明了主线程中可以有多个Handler。
Handler 在 sendMessageAtTime() 时，会把自身填入 msg.target
public boolean sendMessageAtTime(Message msg, long uptimeMillis)
{
boolean sent = false;
MessageQueue queue = mQueue;
if (queue != null) {
msg.target = this;
sent = queue.enqueueMessage(msg, uptimeMillis);
}
else {
RuntimeException e = new RuntimeException(
this + " sendMessageAtTime() called with no mQueue");
Log.w("Looper", e.getMessage(), e);
}
return sent;
}
然后在 Looper.loop() 不断从 MessageQueue 中获取 Message 处理的时候，会根据 msg.target 去调用对应的 dispatchMessage ， 这边的 msg.target 就是前面的 handler
public static final void loop() {
Looper me = myLooper();
MessageQueue queue = me.mQueue;
while (true) {
Message msg = queue.next(); // might block
if (msg != null) {
if (msg.target == null) {
return;
}
if (me.mLogging!= null) me.mLogging.println(
">>>>> Dispatching to " + msg.target + " "
+ msg.callback + ": " + msg.what
);
msg.target.dispatchMessage(msg);
if (me.mLogging!= null) me.mLogging.println(
"<<<<< Finished to " + msg.target + " "
+ msg.callback);
msg.recycle();
}
}
}
4. MessageQueue 的数据结构？多个线程往MessageQueue添加数据，如何保证线程安全？
MessageQueue 是一种先进先出的数据结构，底层实现是按时排序的单向链表，当有 Message 入队时，按照 Message 的 when 值排序插入，然后出队时则去表头的 Message；
在MessageQueue.enqueueMessage() 和MessageQueue.next() 的时候都会用到同步锁synchronized 保证线程安全
final boolean enqueueMessage(Message msg, long when) {
if (msg.when != 0) {
throw new AndroidRuntimeException(msg + " This message is already in use.");
}
if (msg.target == null && !mQuitAllowed) {
throw new RuntimeException("Main thread not allowed to quit");
}
synchronized (this) {
if (mQuiting) {
RuntimeException e = new RuntimeException(msg.target + " sending message to a Handler on a dead thread");
Log.w("MessageQueue", e.getMessage(), e);
return false;
} else if (msg.target == null) {
mQuiting = true;
}
msg.when = when;
Message p = mMessages;
if (p == null || when == 0 || when < p.when) {
msg.next = p;
mMessages = msg;
this.notify();
} else {
Message prev = null;
while (p != null && p.when <= when) {
prev = p;
p = p.next;
}
msg.next = prev.next;
prev.next = msg;
this.notify();
}
}
return true;
}
Message next() {
final long ptr = mPtr;
if (ptr == 0) {
return null;
}
int pendingIdleHandlerCount = -1; // -1 only during first iteration
int nextPollTimeoutMillis = 0;
for (;;) {
if (nextPollTimeoutMillis != 0) {
Binder.flushPendingCommands();
}
nativePollOnce(ptr, nextPollTimeoutMillis);
synchronized (this) {
// Try to retrieve the next message. Return if found.
final long now = SystemClock.uptimeMillis();
Message prevMsg = null;
Message msg = mMessages;
if (msg != null && msg.target == null) {
// Stalled by a barrier. Find the next asynchronous message in the queue.
do {
prevMsg = msg;
msg = msg.next;
} while (msg != null && !msg.isAsynchronous());
}
if (msg != null) {
if (now < msg.when) {
// Next message is not ready. Set a timeout to wake up when it is ready.
nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
} else {
// Got a message.
mBlocked = false;
if (prevMsg != null) {
prevMsg.next = msg.next;
} else {
mMessages = msg.next;
}
msg.next = null;
if (DEBUG) Log.v(TAG, "Returning message: " + msg);
msg.markInUse();
return msg;
}
} else {
// No more messages.
nextPollTimeoutMillis = -1;
}
...
}
}
5. 为什么主线程可以new Handler？如果子线程想要new handler需要做哪些工作？
因为在主线程中已经提前添加了 Looper.prepareMainLooper() 和Looper.loop()，如果子线程想要调用new handler，需要调用 Looper.prepare() 和Looper.loop()
//\frameworks\base\core\java\android\app\ActivityThread.java
public static void main(String[] args) {
...
Looper.prepareMainLooper();
long startSeq = 0;
if (args != null) {
for (int i = args.length - 1; i >= 0; --i) {
if (args[i] != null && args[i].startsWith(PROC_START_SEQ_IDENT)) {
startSeq = Long.parseLong(
args[i].substring(PROC_START_SEQ_IDENT.length()));
}
}
}
ActivityThread thread = new ActivityThread();
thread.attach(false, startSeq);
if (sMainThreadHandler == null) {
sMainThreadHandler = thread.getHandler();
}
if (false) {
Looper.myLooper().setMessageLogging(new
LogPrinter(Log.DEBUG, "ActivityThread"));
}
Looper.loop();
}
csharp
public static void prepareMainLooper() {
prepare(false) ;
synchronized (Looper.class) {
if (sMainLooper != null) {
throw new IllegalStateException("The main Looper has already been prepared.");
}
sMainLooper = myLooper();
}
}
6. Handler.postDelayed() 消息时间准确吗？实现原理？
实际上，这个问题与线程安全性为同一个问题，多线程中线程一旦安全，时间就不能准确；时间一旦准确，线程就一定不安全。 因为多个线程去访问这个队列的时候，在放入队列和取出消息的时候都会加锁，当第一个线程还没有访问完成的时候，第二个线程就无法使用，所以他实际的时间会被延迟。所以，Handler所发送的Delayed消息时间基本准确，但不完全准确。
实现原理：postDelayed最终会调用一个带延迟参数的 sendMessageAtTime，然后通过MessageQueue.enqueueMessage将带延迟时间参数的msg按照时间排序插入到MessageQueue。MessageQueue是一个按时间排序的单向链表，Looper 从 MessageQueue取msg的时候，会判断当前时间是否到达链表头第一个msg 的延迟时间，如果还没到，就会通过比较延迟时间和当前时间计算出还需要等待的时间，然后通过native函数nativePollOnce进行一个阻塞等待，直到等待时间到达再唤醒线程执行msg;
7. MessageQueue中没有消息的时候会发生什么？为什么Looper.loop不会阻塞主线程？
MessageQueue 队列为空时，Looper.loop() 的死循环不会退出也不会执行，而是阻塞在MessageQueue.next() 中的 nativePollOnce() 方法中，进入休眠状态，等待新消息到来重新唤醒。这边会涉及到底层linux 的 pipe 和 epoll 机制实现。
8. 为什么Handler死循环不会卡死？
应用出现ANR卡死和Looper的死循环其实是没有关系的。应用没有消息需要处理的时候，它是在休眠，释放线程了；而ANR是指消息没来得及处理，比如按键和触摸事件在5s内没有处理掉，或者前台广播在10s内没有处理掉等，导致卡死；
9. IdleHandler 了解么？
IdelHandler 是MessageQueue中的一个静态内部接口，当 Looper 从 MessageQueue中获取的msg为空，或者执行时间未到时，也就是 MessageQueue空闲时就会去回调 IdleHandler.queueIdle()。
如果 queueIdle() 返回 false，则执行完后，该idlehandler会被剔除，也就是只执行一次，如果返回true，则保留，下次MessageQueue进入空闲状态继续执行；
//\frameworks\base\core\java\android\os\MessageQueue.java
/**
* Callback interface for discovering when a thread is going to block
* waiting for more messages.
*/
public static interface IdleHandler {
/**
* Called when the message queue has run out of messages and will now
* wait for more. Return true to keep your idle handler active, false
* to have it removed. This may be called if there are still messages
* pending in the queue, but they are all scheduled to be dispatched
* after the current time.
*/
boolean queueIdle();
}
Message next() {
......
for (;;) {
......
synchronized (this) {
// 此处为正常消息队列的处理
......
if (mQuitting) {
dispose();
return null;
}
if (pendingIdleHandlerCount < 0
&& (mMessages == null || now < mMessages.when)) {
pendingIdleHandlerCount = mIdleHandlers.size();
}
if (pendingIdleHandlerCount <= 0) {
// No idle handlers to run. Loop and wait some more.
mBlocked = true;
continue;
}
if (mPendingIdleHandlers == null) {
mPendingIdleHandlers = new IdleHandler[Math.max(pendingIdleHandlerCount, 4)];
}
//mIdleHandlers 数组，赋值给 mPendingIdleHandlers
mPendingIdleHandlers = mIdleHandlers.toArray(mPendingIdleHandlers);
}
for (int i = 0; i < pendingIdleHandlerCount; i++) {
final IdleHandler idler = mPendingIdleHandlers[i];
mPendingIdleHandlers[i] = null; // release the reference to the handler
boolean keep = false;
try {
keep = idler.queueIdle();
} catch (Throwable t) {
Log.wtf(TAG, "IdleHandler threw exception", t);
}
if (!keep) {
synchronized (this) {
mIdleHandlers.remove(idler);
}
}
}
pendingIdleHandlerCount = 0;
nextPollTimeoutMillis = 0;
}
}
系统源码中使用例子：ActivityThread.handleResumeActivity()中，在 onResume 方法执行完毕后，调用 Looper.myQueue().addIdleHandler(new Idler()) ，去执行一些资源回收，日志打印等不那么着急的任务。除此之外，在做项目 性能优化 的时候也可以使用 IdleHandler，它在主线程空闲时执行任务，而不影响其他任务的执行。
@Override
public void handleResumeActivity(IBinder token, boolean finalStateRequest, boolean isForward,
String reason) {
// If we are getting ready to gc after going to the background, well
// we are back active so skip it.
unscheduleGcIdler();
mSomeActivitiesChanged = true;
···
//该方法最终会执行 onResume方法
final ActivityClientRecord r = performResumeActivity(token, finalStateRequest, reason);
if (r == null) {
// We didn't actually resume the activity, so skipping any follow-up actions.
return;
}
···
···
r.nextIdle = mNewActivities;
mNewActivities = r;
if (localLOGV) Slog.v(TAG, "Scheduling idle handler for " + r);
Looper.myQueue().addIdleHandler(new Idler());
}
private class Idler implements MessageQueue.IdleHandler {
@Override
public final boolean queueIdle() {
ActivityClientRecord a = mNewActivities;
···
if (a != null) {
mNewActivities = null;
IActivityManager am = ActivityManager.getService();
ActivityClientRecord prev;
do {
//打印一些日志
if (localLOGV) Slog.v(
TAG, "Reporting idle of " + a +
" finished=" +
(a.activity != null && a.activity.mFinished));
if (a.activity != null && !a.activity.mFinished) {
try {
//AMS 进行一些资源的回收
am.activityIdle(a.token, a.createdConfig, stopProfiling);
a.createdConfig = null;
} catch (RemoteException ex) {
throw ex.rethrowFromSystemServer();
}
}
prev = a;
a = a.nextIdle;
prev.nextIdle = null;
} while (a != null);
}
if (stopProfiling) {
mProfiler.stopProfiling();
}
//确认Jit 可以使用，否则抛出异常
ensureJitEnabled();
return false;
}
}
10. 同步屏障了解么？
可以理解为 同步屏障 是为Handler消息机制提供的一种 优先级策略，能提高异步消息的优先级。
Handler机制中有三种消息：同步消息，异步消息和屏障消息，我们正常使用的消息都是同步消息，异步消息可以在Handler构造时设置，也可以通过setAsynchronous进行设置，而屏障消息跟同步消息的区别是target属性为null。Looper从MessageQueue中取消息时，如果没有遇到屏障消息，那么同步消息和异步消息是一样的，如果遇到屏障消息，则会屏蔽掉该消息之后的所有同步消息，只执行异步消息。
在UI绘制流程中，就会使用同步屏障和异步消息，保证在Vsync信号过来时，异步任务能被优先处理，从而让绘制任务被及时执行，避免界面卡顿。
@UnsupportedAppUsage
Message next() {
for (;;) {
nativePollOnce(ptr, nextPollTimeoutMillis);
synchronized (this) {
Message msg = mMessages;
//如果msg.target为空，也就是说是一个同步屏障消息，则进入这个判断里面
if (msg != null && msg.target == null) {
// Stalled by a barrier. Find the next asynchronous message in the queue.
//在这个while循环中，找到最近的一个异步消息
do {
prevMsg = msg;
msg = msg.next;
} while (msg != null && !msg.isAsynchronous());
}
//找到了异步消息
if (msg != null) {
//如果消息的处理时间小于当前时间 则等待
if (now < msg.when) {
// Next message is not ready. Set a timeout to wake up when it is ready.
nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
} else {
// Got a message.
//处理消息
mBlocked = false;
//将异步消息移除
if (prevMsg != null) {
prevMsg.next = msg.next;
} else {
mMessages = msg.next;
}
msg.next = null;
if (DEBUG) Log.v(TAG, "Returning message: " + msg);
msg.markInUse();
//返回异步消息
return msg;
}
} else {
// No more messages.
//没有找到异步消息则进入阻塞状态，等待被唤醒
nextPollTimeoutMillis = -1;
}
...
}
另外需要注意的是：同步屏障不会自动移除，使用完成之后需要手动移除，不然会造成同步消息无法处理。也就是上边提到的，通过removeSyncBarrier(int token) 方法进行移除，token就是之前添加屏障时返回的token。
public void removeSyncBarrier(int token){
}
11. Handler为什么内存泄漏？如何解决？
原因
Handler的Message被存储在MessageQueue中，有些Message并不能马上被处理，它们在MessageQueue中存在的时间会很长，这就会导致Handler无法被回收。因为 Handler是非静态的匿名内部类的实例，它会隐形的持有外部类Activity，从而导致Activity不能被回收，导致Activity泄漏内存
解决方法
- 使用static 修饰的handler，使用弱引用activity对象，因为要使用activity对象中的成员（因为静态内部类不持有外部类的引用，所以使用静态的handler不会导致activity的泄露）；
- 单独定义handler，同样可以弱引用activity；
- 使用内部类的handler，在onDestroy方法中removeCallbacksAndMessages；
- 还有一种方法是直接使用避免内存泄漏的Handler开源库WeakHandler；
12. 如何创建Message？为什么？
创建 Message 建议使用 Message.obtain()，不要使用 new message()。因为 Message 类里维护了一个 sPool 的对象，可以理解为一个 Message 链表，这个链表的默认最大长度为 50。在 Android 消息机制中，每当一个 Message 对象被处理完成之后，就会被放入这个池中，为我们提供了复用。当我们调用 Message.obtain()方法时，如果复用池中存在的 Message 对象，我们就不会去创建一个新的 Message 对象。这样就避免频繁创建和销毁 Message 对象带来的性能开销。减小内存的抖动和OOM。
/** Constructor (but the preferred way to get a Message is to call {@link #obtain() Message.obtain()}).
*/
public Message() {
}
public static Message obtain() {
synchronized (sPoolSync) {
if (sPool != null) {
Message m = sPool;
sPool = m.next;
m.next = null;
m.flags = 0; // clear in-use flag
sPoolSize--;
return m;
}
}
return new Message();
}
13. HandlerThread
Handlerthread 是继承于Thread的一个类，用于开启一个带有looper的新线程，可以使用这个looper来创建Handler，需要注意的是必须调用start() 方法开启线程。因为 start() 可以调用线程的 run() 方法，而 HandlerThread.run()中会调用 Looper.prepare() 和 Looper.loop()，从而为子线程绑定 Looper，相当于做了一层封装，方便用户使用Handler。
//frameworks\base\core\java\android\os\HandlerThread.java
/*
Handy class for starting a new thread that has a looper.
The looper can then be used to create handler classes.
Note that start() must still be called.
*/
public class HandlerThread extends Thread {
...
@Override
public void run() {
mTid = Process.myTid();
Looper.prepare();// HandlerThread在start()的时候执行run()方法，而Looper就是在这里被创建的
synchronized (this) {
mLooper = Looper.myLooper();
notifyAll();
}
Process.setThreadPriority(mPriority);
onLooperPrepared();
Looper.loop();
mTid = -1;
}
}
Handler 和 HandlerThread 的配合使用方式
HandlerThread thread1 = new HandlerThread("test1");
thread1.start();
Handler mHandler = new Handler(thread1.getLooper()){
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case DownloadThread.TYPE_START:
Log.e(TAG, "4.主线程知道Download线程开始下载了...这时候可以更改主界面UI");
break;
default:
break;
}
super.handleMessage(msg);
}
}
14. IntentService
IntentService 是继承于 Service 的基础类， 本质上是一个 Service。主要是用于响应基于 Intent 的异步请求。客户端通过 startService(Intent) 发送请求，IntentService 接收到请求后开启，并在新建的子线程中按序处理异步的 Intent 请求，在同一时间只有一个请求会被处理。当完成所有请求后，IntentService 会自行关闭。
为什么官方提供了 Service 之后，又提供 IntentService呢？
Service 默认是运行在主线程的，如果我们需要在 Service 中处理一些耗时任务，那么我们还需要去手动的创建线程或者使用线程池去处理耗时任务（否则会出现ANR），然后在处理完以后手动关闭Service，而 IntentService 已经帮我们做好了这些工作，我们只需要在 onHandleIntent中写上耗时任务的代码，就可以在子线程中去执行，因为 onHandleIntent是运行在子线程中的，并且在任务执行完以后，IntentService 会自己执行stopSelf(startId)方法，自行关闭。
用 IntentService 有什么好处呢？
首先，我们省去了在 Service 中手动开线程的麻烦，第二，当操作完成时，我们不用手动停止 Service。
ServiceIntent 的使用例子，可参考 源码；执行效果如下图：
//\frameworks\base\core\java\android\app\IntentService.java
/**
* IntentService is an extension of the {@link Service} component class that
* handles asynchronous requests (expressed as {@link Intent}s) on demand.
* Clients send requests
* through {@link android.content.Context#startService(Intent)} calls; the
* service is started as needed, handles each Intent in turn using a worker
* thread, and stops itself when it runs out of work.
*/
@Deprecated
public abstract class IntentService extends Service {
private volatile Looper mServiceLooper;
@UnsupportedAppUsage
private volatile ServiceHandler mServiceHandler;
private String mName;
private boolean mRedelivery;
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);
}
}
public IntentService(String name) {
super();
mName = name;
}
...
@Override
public void onCreate() {
super.onCreate();
//这边就使用到了 HandlerThread 的工具类
HandlerThread thread = new HandlerThread("IntentService[" + mName + "]");
thread.start();
mServiceLooper = thread.getLooper();
// mServiceHandler 本质是 Handler，使用了 mServiceLooper 去创建
mServiceHandler = new ServiceHandler(mServiceLooper);
}
@Override
public void onStart(@Nullable Intent intent, int startId) {
Message msg = mServiceHandler.obtainMessage();
msg.arg1 = startId;
msg.obj = intent;
mServiceHandler.sendMessage(msg);
}
@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 onDestroy() {
mServiceLooper.quit();
}
/**
* This method is invoked on the worker thread with a request to process.
* Only one Intent is processed at a time, but the processing happens on a
* worker thread that runs independently from other application logic.
* So, if this code takes a long time, it will hold up other requests to
* the same IntentService, but it will not hold up anything else.
* When all requests have been handled, the IntentService stops itself,
* so you should not call {@link #stopSelf}.
*
* @param intent The value passed to {@link
* android.content.Context#startService(Intent)}.
* This may be null if the service is being restarted after
* its process has gone away; see
* {@link android.app.Service#onStartCommand}
* for details.
*/
@WorkerThread
protected abstract void onHandleIntent(@Nullable Intent intent);
}
-
linux的epoll机制
- epoll机制，是一种IO多路复用机制，可以同时监控多个描述符，当某个描述符就绪(读或写就绪)，则立刻通知相应程序进行读或写操作，本质同步I/O，即读写是阻塞的。 所以说，主线程大多数时候都是处于休眠状态，并不会消耗大量CPU资源。
/**
* A Handler allows you to send and process Message and Runnable
* objects associated with a thread's MessageQueue. Each Handler
* instance is associated with a single thread and that thread's message
* queue. When you create a new Handler it is bound to a Looper.
* It will deliver messages and runnables to that Looper's message
* queue and execute them on that Looper's thread.
*
* There are two main uses for a Handler: (1) to schedule messages and
* runnables to be executed at some point in the future; and (2) to enqueue
* an action to be performed on a different thread than your own.
*
*
Scheduling messages is accomplished with the
* {@link #post}, {@link #postAtTime(Runnable, long)},
* {@link #postDelayed}, {@link #sendEmptyMessage},
* {@link #sendMessage}, {@link #sendMessageAtTime}, and
* {@link #sendMessageDelayed} methods. The post versions allow
* you to enqueue Runnable objects to be called by the message queue when
* they are received; the sendMessage versions allow you to enqueue
* a {@link Message} object containing a bundle of data that will be
* processed by the Handler's {@link #handleMessage} method (requiring that
* you implement a subclass of Handler).
*
*
When posting or sending to a Handler, you can either
* allow the item to be processed as soon as the message queue is ready
* to do so, or specify a delay before it gets processed or absolute time for
* it to be processed. The latter two allow you to implement timeouts,
* ticks, and other timing-based behavior.
*
*
When a
* process is created for your application, its main thread is dedicated to
* running a message queue that takes care of managing the top-level
* application objects (activities, broadcast receivers, etc) and any windows
* they create. You can create your own threads, and communicate back with
* the main application thread through a Handler. This is done by calling
* the same post or sendMessage methods as before, but from
* your new thread. The given Runnable or Message will then be scheduled
* in the Handler's message queue and processed when appropriate.
*/
public class Handler {
}
如果你还对Handler 没有完全掌握话，又想要在最短的时间里吃透它，可以参考一下《Android Framework核心知识点》，里面内容包含了：Init、Zygote、SystemServer、Binder、Handler、AMS、PMS、Launcher……等知识点记录。
《Framework 核心知识点汇总手册》:https://qr18.cn/AQpN4J
Handler 机制实现原理部分：
1.宏观理论分析与Message源码分析
2.MessageQueue的源码分析
3.Looper的源码分析
4.handler的源码分析
5.总结
Binder 原理：
1.学习Binder前必须要了解的知识点
2.ServiceManager中的Binder机制
3.系统服务的注册过程
4.ServiceManager的启动过程
5.系统服务的获取过程
6.Java Binder的初始化
7.Java Binder中系统服务的注册过程
Zygote ：
- Android系统的启动过程及Zygote的启动过程
- 应用进程的启动过程
AMS源码分析 ：
- Activity生命周期管理
- onActivityResult执行过程
- AMS中Activity栈管理详解
深入PMS源码：
1.PMS的启动过程和执行流程
2.APK的安装和卸载源码分析
3.PMS中intent-filter的匹配架构
WMS：
1.WMS的诞生
2.WMS的重要成员和Window的添加过程
3.Window的删除过程
《Android Framework学习手册》：https://qr18.cn/AQpN4J
- 开机Init 进程
- 开机启动 Zygote 进程
- 开机启动 SystemServer 进程
- Binder 驱动
- AMS 的启动过程
- PMS 的启动过程
- Launcher 的启动过程
- Android 四大组件
- Android 系统服务 - Input 事件的分发过程
- Android 底层渲染 - 屏幕刷新机制源码分析
- Android 源码分析实战
