主线程是怎么运行起来
是从ActivityThread的main方法开始的。
//ActivityThread的main方法
public static void main(String[] args) {
.....省略若干行代码
Looper.prepareMainLooper();
.....省略后面若干行代码
Looper.loop();
.....省略后面若干行代码
}//ActivityThread中的main方法中调用了Looper的prepareMainLooper()，这个方法中又调用了Looper的prepare()方法，
//最后调用了Looper的loop()方法。
//Looper的prepare()方法，创建了Looper对象，利用可以让线程内单例的类ThreadLocal，保证了主线程内的Looper是单例的。
//这里是在主线程中运行的，所以通过set()保存的的Looper也是主线程的
public static final void prepare() {
if (sThreadLocal.get() != null) {
throw new RuntimeException("Only one Looper may be created per thread");
}
sThreadLocal.set(new Looper(true));
} //Looper的构造方法
//这是Looper的构造方法，在构造方法中初始化了一个消息队列MessageQueue，初始化Looper就会得到一个MessageQueue
private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);
mRun = true;
mThread = Thread.currentThread();
}//Looper的loop()方法
//Looper类的loop()方法，它是一个死循环，不断的从消息队列中取消息，if(msg==null){return；}如果没有消息就阻塞等待消息。
如果有消息的话，就会取出来，然后下一条消息会代替取走的消息的位置从下面顶上来等待被取走。
它是这样取出一条消息的，调用消息队列MessageQueue的next()方法返回一个消息对象，Message msg = queue.next();
然后这个消息对象调用了msg.target.dispatchMessage(msg)方法去派遣消息，这个方法中的最后会调用handleMessage(msg);
这个msg.target其实就是Message中保存的一个handler对象，就是因为它在类中有一个Handler对象的字段，所以它可以调用handleMessage()方法。
public static void loop() {
final Looper me = myLooper();
if (me == null) {
throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
}
final MessageQueue queue = me.mQueue;
//省略若干行代码
for (;;) {
Message msg = queue.next(); // might block
if (msg == null) {
// No message indicates that the message queue is quitting.
return;
}
//省略若干行代码
msg.target.dispatchMessage(msg);
//省略若干行代码
msg.recycleUnchecked();
}
}//Looper类中的myLooper()方法，获取之前prepare()方法中调用的set()方法设置的Looper。
public static @Nullable Looper myLooper() {
return sThreadLocal.get();
}//Handler的dispatchMessage(msg)方法
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}/Looper的loop()方法做的就是无限循环从消息队列里取消息，然后调用dispatchMessage(msg)，dispatchMessage(msg)方法里最后调用的是handleMessage(Message msg)这个方法，其实这个方法就是平时在主线程中自定义的重写的方法。最后的最后就是执行这里的方法。/
public void handleMessage(Message msg) {
}如果是执行的这条路线
if (msg.callback != null) {
handleCallback(msg);
}
就是去执行了创建了Runnable对象的重写的run()方法。
private static void handleCallback(Message message) {
message.callback.run();
}还有一点是这个的msg.callback是什么。
它时一个Runnable callback对象。
public class MainActivity extends Activity {
Handler handler=new Handler();
Runnable callback=new Runnable() {
@Override
public void run() {
//....
}
};
@Override
protected void onCreate(Bundle savedInstanceState) {
// TODO Auto-generated method stub
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_second);
}
//这种创建消息的方式，需要传入Handler对象和Runnable对象，然后会回调Runnable的run方法。
Message message=Message.obtain(handler, callback);
handler.sendMessage(message)；
}
//Handler的dispatchMessage(msg)方法中的另一个分支判断
else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
//这里的mCallback其实是一个Callback mCallback。
//Callback是Handler类中的一个内部接口。然后如果创建它的话，就要去实现它，创建Callback接口的对象的话，就要
//重写handleMessage(Message msg)方法。
public interface Callback {
public boolean handleMessage(Message msg);
}
当子线程执行完一个耗时操作之后，把结果通过sendMessage()发送给主线程的MessageQueue中。
Message.obtain()方法解析；它用来获取一个消息对象，并且会取走第一个消息，然后后面的消息会往前移动到链表第一个位置
(Tips：一般最好用obtain()方法来获得消息对象，不要用new。)
消息队列顺序的维护是使用单链表的形式来维护的
把消息池的第一条数据取出来，然后把第二条放到原来第一条的位置，等待下次的被轮询。
mPool并不是消息池的那种集合，只是一个消息对象，它是消息池里的第一个对象。
这里的next是一个Message类型的成员属性，用来标识下一条消息。
在这里把第一条消息mPool赋值给Message类型的m变量，让m和mPool同时指向一个Message对象，目前它们首地址是相等的。然后把mPool指向m.next，
这个m.next是链表第一个位置的对象的一个成员属性，它的意义是代表链接了链表第二个位置的对象的next成员。最后把m.next置为空，代表它从链
表中断开，那么mPool之前作为链表中第二个位置，断开后就变成第一个位置了，最后把m返回。
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();
}Handler
//Handler的空参构造方法
public Handler() {//空参构造方法调用了两个参数的构造方法
this(null, false);
}//Handler的两个参数的构造方法，在空参构造方法中调用
public Handler(Callback callback, boolean async) {
........省略看不懂
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;
}//Looper类的myLooper()方法
public static final Looper myLooper(){
return (Looper)sThreadLocal.get();//重点看这一行
}可以看到在创建Handler的时候会调用两个参数的构造方法，
然后通过在Handler的构造方法中调用这个Looper.myLooper()，得到一个Looper mLooper成员变量 ;
myLooper()方法通过(Looper)sThreadLocal.get();得到之前主线程调用prepare()方法中的sThreadLocal.set(new Looper(true))保存的Looper对象。
这里创建的Looper对象就是主线程创建的，它是会确保这个对象在本线程内单例，也就是调用的只有这一个Looper对象。
初始化Looper时，Looper的构造方法中指明了会初始化一个MessageQueue mQueue = new MessageQueue(quitAllowed);
然后在在创建Handler的时候，Handler的构造方法中通过mQueue = mLooper.mQueue;将Handler中的mQueue与Looper中的mQueue相关联。
在子线程发送消息,其实发送消息都是Handler类中的方法
//发送消息，里面返回调用了sendMessageDelayed()方法。
public final boolean sendMessage(Message msg){
return sendMessageDelayed(msg, 0);
}//发送空消息，会调用endEmptyMessage()，最后也是调用了sendMessageDelayed()方法。
public final boolean sendEmptyMessage(int what){
return sendEmptyMessageDelayed(what, 0);
}//虽然说方法名是发送空消息，但是还是创建了一个Message对象。
public final boolean sendEmptyMessageDelayed(int what, long delayMillis) {
Message msg = Message.obtain();
msg.what = what;
return sendMessageDelayed(msg, delayMillis);
}//sendMessageDelayed()方法，最后是调用了sendMessageAtTime()方法。
public final boolean sendMessageDelayed(Message msg, long delayMillis){
if (delayMillis < 0) {
delayMillis = 0;
}
return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
}//sendEmptyMessageAtTime()方法。创建了Message对象并作为参数，传递给sendMessageAtTime()方法。
public final boolean sendEmptyMessageAtTime(int what, long uptimeMillis) {
Message msg = Message.obtain();
msg.what = what;
return sendMessageAtTime(msg, uptimeMillis);
}//sendMessageAtTime()方法，这里获得了消息队列MessageQueue queue = mQueue; 这个mQueue是创建Handler的构造方法中得到的。
//这里创建了MessageQueue对象，把之前得到的Message对象和MessageQueue对象做为参数发送给enqueueMessage(queue, msg, 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);
}//enqueueMessage()方法，这里的msg.target = this; msg.target是Handler target。这个方法的意义就是把handler也就是target保存到了
//Message msg对象里面了。
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
msg.target = this;
if (mAsynchronous) {
msg.setAsynchronous(true);
}
return queue.enqueueMessage(msg, uptimeMillis);
}//最后调用了MessageQueue类中的enqueueMessage()方法,这个方法是让Message对象插入到MessageQueue消息队列。
//这里面的代码，说明了如果消息队列中没有第一条消息，就把当前消息作为消息队列中的第一条消息；如果有消息，则根据它们的延迟发送消息
//的时间来做作为优先级，去排列它们的顺序。
//mMessage是第一条消息的对象，
Message p = mMessages;
if (p == null || when == 0 || when < p.when) {
msg.next = p;
mMessages = msg;
needWake = mBlocked;
} else {
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;
}
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) {
msg.next = p;
mMessages = msg;
needWake = mBlocked;
} else {
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;
}
if (needWake) {
nativeWake(mPtr);
}
}
return true;
}总结：从ActivityThread的main方法开始运行了主线程，主函数中调用了Looper的prepareMainLooper()，这个方法中又会触发Looper的prepare()方法，这个方法创建了一个Looper对象，并且Looper初始化会初始化一个MessageQueue象。prepareMainLooper()方法的最后又调用了Looper的loop()方法，这是一个死循环，不断的从消息队列中取消息。
如果有消息就会从MessageQueue中取出一个Message消息，就会去执行msg.target.dispatchMessage(msg); 这个方法会触发handleMessage()方法，也就是平时我们自己写的那个方法。
如果没有就会阻塞，就等待子线程发送消息到消息队列，届时就会被唤醒。
子线程发送消息，会调用很多sendxxxxxMessage()方法，一路上创建绑定了MessageQueue，Message，Handler，最后触发了MessageQueue enqueueMessage()方法，把消息对象入列到消息队列，其中会进行一些消息的延迟的处理，优先级的判断来排序消息，如果消息要入列的时候，loop()方法中当时没有消息被阻塞了，那么入列的时候会唤醒它，通过一个布尔值的标识来标记。
扫一扫
700
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
