Handler
1.callBack 是一个接口,里面是handlerMessage
2.hadlerMessage是一个空方法,子类可实现,可不实现;对于抽象方法,如果子类是非抽象类,则必须实现父类中所有抽象方法,如果是抽象类,则可不实现
3.handler中的方法大概有这么几种,
1.obtainMessage,其实是调用的Message的obtain函数
2.sendMessage 和postMessage,以及在构造函数中传入callback处理消息
3.hasMessage,hasCallback
4.removeMessage,removerCallBack
Message
1.Message实现了Parcelable,
2.Message 主要就是Obtain方法,因为handler里面的obtain也是调用的这里的obtain,
3.Max_pool_size 是50,猜测是message pool值的大小
4.Message也是一个final类
MessageQueue 消息队列,
1.是一个Final类,不可被继承
2.idle静止状态,设备不充电且屏幕关闭的情况下,会逐渐进入静止状态,
Looper:
里面有一个ThreadLocal
Looper也是一个final类
流程分析:
1.创建handler,一般是无参构造,然后重写handleMessage方法
2.发送消息,以sendEmptyMessage为例,sendEmptyMessage 会调用
public final boolean sendEmptyMessage(int what) {
//调用sendEmptyMessageDelayed()函数,然后延时设置为0 return sendEmptyMessageDelayed(what, 0); }
然后接着看
public final boolean sendEmptyMessageDelayed(int what, long delayMillis) { Message msg = Message.obtain(); msg.what = what; return sendMessageDelayed(msg, delayMillis); }
获取一个message对象之后,sendMessageDelayed
public final boolean sendMessageDelayed(Message msg, long delayMillis) { if (delayMillis < 0) { delayMillis = 0; } return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis); }
这里是是调用了,sendMessageAtTime ,SystemClock.uptimeMillis是自从开机,除了手机深度睡眠之外,一直增加的数字,
public boolean sendMessageAtTime(Message msg, long uptimeMillis) { MessageQueue queue = mQueue; if (queue == null) { RuntimeException e = new RuntimeException( this + " sendMessageAtTime() called with no mQueue"); Log.w("Looper", e.getMessage(), e); return false; } return enqueueMessage(queue, msg, uptimeMillis); }
这里赋值了一个Messagequeue,
public Handler(Callback callback, boolean async) { ... mLooper = Looper.myLooper(); .... mQueue = mLooper.mQueue;
mCallback = callback; mAsynchronous = async; }
在构造函数里面获取了Looper轮询器,然后根据轮询器又获取了消息队列,handler的构造方法可以分为两类,一类是使用默认创建,最终都会调用到上面这个构造方法,另一类就是下面这种了,指定looper,指定callback,指定是否异步,handler默认是同步的:
public Handler(Looper looper, Callback callback, boolean async) { mLooper = looper; mQueue = looper.mQueue; mCallback = callback; mAsynchronous = async; }
接下来看Looper.myLooper(),因为是通过looper获取的messagequeue,
public static @Nullable Looper myLooper() { return sThreadLocal.get(); }
sThreadLocal是一个looper的ThreadLocal,所以这里可以看到,每一个handler都有自己的looper,虽然都是looper,但之间并不影响。然后我们再看looper.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)); }
就是在threadlocal中加入了这样一个变量。因为mainThread已经存在一个looper,所以在mainthread中不用调用looper.prepare(),而在子线程中需要去调用looper.prepare(),而且与主线程中不同的是,子线程的looper还是可以退出的,quitAllowed,接下来,我们看
messageQueue,在handler的构造函数中看到mQueue = looper.mQeue 可以去看由此可知,每个looper带有一个消息队列,也就是handler之间的messageQueue不冲突。
private Looper(boolean quitAllowed) { mQueue = new MessageQueue(quitAllowed); mThread = Thread.currentThread(); }
在looper的构造函数中,new 了一个messageQueue,所以由上面的流程可以看出,一个创建一个handler的之前,需要创建了一个looper,looper创建是调用prepare方法,创建looper的时候就附带创建了消息队列。最主要的是looper的保存是通过threadlocal保证looper各个handelr之间互不影响。
上面分析知道,发送消息,最终都会调用sendMessageAtTime, time的计算有systemClock.uptime+delaytime计算而来,接下来就是enqueuMessage(),这是handler里面的
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) { msg.target = this; if (mAsynchronous) { msg.setAsynchronous(true); } return queue.enqueueMessage(msg, uptimeMillis); }
可以看出,调用了队列的enqueuemessage,队列的
boolean enqueueMessage(Message msg, long when) { if (msg.target == null) { throw new IllegalArgumentException("Message must have a target."); } if (msg.isInUse()) { throw new IllegalStateException(msg + " This message is already in use."); } synchronized (this) { if (mQuitting) { IllegalStateException e = new IllegalStateException( msg.target + " sending message to a Handler on a dead thread"); Log.w(TAG, e.getMessage(), e); msg.recycle(); return false; } msg.markInUse(); msg.when = when; Message p = mMessages; boolean needWake; if (p == null || when == 0 || when < p.when) { // New head, wake up the event queue if blocked. msg.next = p; mMessages = msg; needWake = mBlocked; } else { // Inserted within the middle of the queue. Usually we don't have to wake // up the event queue unless there is a barrier at the head of the queue // and the message is the earliest asynchronous message in the queue. needWake = mBlocked && p.target == null && msg.isAsynchronous(); Message prev; for (;;) { prev = p; p = p.next; if (p == null || when < p.when) { break; } if (needWake && p.isAsynchronous()) { needWake = false; } } msg.next = p; // invariant: p == prev.next prev.next = msg; } // We can assume mPtr != 0 because mQuitting is false. if (needWake) { nativeWake(mPtr); } } return true; }
由
msg.when = when; Message p = mMessages; boolean needWake; if (p == null || when == 0 || when < p.when) { // New head, wake up the event queue if blocked. msg.next = p; mMessages = msg; needWake = mBlocked;
可知,当前没有消息或者没有延时,或者插入的消息要比当前的消息先执行,插入的消息的next指向当前的消息,下面接着看,不符合上述三个条件的插入
} else { // Inserted within the middle of the queue. Usually we don't have to wake // up the event queue unless there is a barrier at the head of the queue // and the message is the earliest asynchronous message in the queue. needWake = mBlocked && p.target == null && msg.isAsynchronous(); Message prev; for (;;) { prev = p; p = p.next; if (p == null || when < p.when) { break; } if (needWake && p.isAsynchronous()) { needWake = false; } } msg.next = p; // invariant: p == prev.next prev.next = msg; }
先声明一个prev变量,然后是一个死循环,主要看这里
if (p == null || when < p.when) { break; }
如果消息队列下面没有消息了,或者,要插入的消息比当前的消息先执行,就将消息插入这个位置:
msg.next = p; // invariant: p == prev.next prev.next = msg;
插入的消息next指向p,上一个消息指向插入的消息,这里注意,插入消息是一个synchornize操作。消息插入完了,剩下就是执行操作:我们所知的在主线程中创建了looper,具体来讲就是在ActivityThread。java里面实现的,以下是ActivityThread中looper的实现:
final Looper mLooper = Looper.myLooper();
声明一个成员变量,mLooper,然后看main函数:
public static void main(String[] args) { Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "ActivityThreadMain"); SamplingProfilerIntegration.start(); // CloseGuard defaults to true and can be quite spammy. We // disable it here, but selectively enable it later (via // StrictMode) on debug builds, but using DropBox, not logs. CloseGuard.setEnabled(false); Environment.initForCurrentUser(); // Set the reporter for event logging in libcore EventLogger.setReporter(new EventLoggingReporter()); // Make sure TrustedCertificateStore looks in the right place for CA certificates final File configDir = Environment.getUserConfigDirectory(UserHandle.myUserId()); TrustedCertificateStore.setDefaultUserDirectory(configDir); Process.setArgV0("<pre-initialized>"); Looper.prepareMainLooper(); ActivityThread thread = new ActivityThread(); thread.attach(false); if (sMainThreadHandler == null) { sMainThreadHandler = thread.getHandler(); } if (false) { Looper.myLooper().setMessageLogging(new LogPrinter(Log.DEBUG, "ActivityThread")); } // End of event ActivityThreadMain. Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER); Looper.loop(); throw new RuntimeException("Main thread loop unexpectedly exited"); }
可以找到looper.prepareMainLooper,以及looper.loop,这就解决了之前loop函数在哪里调用的问题:思考:那么在子线程是不是需要我们手动调用loop函数呢?答案是需要!
https://www.zhihu.com/question/34652589
最后是参考:http://mp.weixin.qq.com/s/SVSJ7imNj6lsbuTE9ix2Zg
还有message的消息池,大小为50;