Android消息循环机制源码深入理解

 //1. 主线程
 handler handler = new myhandler();

 //2. 非主线程
 handlerthread handlerthread = new handlerthread("handlerthread");
 handlerthread.start();
 handler handler = new handler(handlerthread.getlooper());

 //发送消息
 handler.sendmessage(msg);

 //接收消息
 static class myhandler extends handler {
  //对于非主线程处理消息需要传looper，主线程有默认的smainlooper
  public myhandler(looper looper) {
   super(looper);
  }

  @override
  public void handlemessage(message msg) {
   super.handlemessage(msg);
  }
 }

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));
}

public static looper mylooper() {
 return sthreadlocal.get();
}

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;

 // make sure the identity of this thread is that of the local process,
 // and keep track of what that identity token actually is.
 binder.clearcallingidentity();
 final long ident = binder.clearcallingidentity();

 for (;;) {
  message msg = queue.next(); // might block
  if (msg == null) {
   // no message indicates that the message queue is quitting.
   return;
  }

  // this must be in a local variable, in case a ui event sets the logger
  printer logging = me.mlogging;
  if (logging != null) {
   logging.println(">>>>> dispatching to " + msg.target + " " +
     msg.callback + ": " + msg.what);
  }

  msg.target.dispatchmessage(msg);

  if (logging != null) {
   logging.println("<<<<< finished to " + msg.target + " " + msg.callback);
  }

  // make sure that during the course of dispatching the
  // identity of the thread wasn't corrupted.
  final long newident = binder.clearcallingidentity();
  if (ident != newident) {
   log.wtf(tag, "thread identity changed from 0x"
     + long.tohexstring(ident) + " to 0x"
     + long.tohexstring(newident) + " while dispatching to "
     + msg.target.getclass().getname() + " "
     + msg.callback + " what=" + msg.what);
  }

  msg.recycleunchecked();
 }
}

public void handlemessage(message msg) {
}

public void dispatchmessage(message msg) {
 if (msg.callback != null) {
  handlecallback(msg);
 } else {
  if (mcallback != null) {
   if (mcallback.handlemessage(msg)) {
    return;
   }
  }
  handlemessage(msg);
 }
}

private static void handlecallback(message message) {
 message.callback.run();
}

public final message obtainmessage()
{
 return message.obtain(this);
}

public final boolean post(runnable r)
{
 return sendmessagedelayed(getpostmessage(r), 0);
}

public final boolean sendmessage(message msg)
{
 return sendmessagedelayed(msg, 0);
}

private static message getpostmessage(runnable r) {
 message m = message.obtain();
 m.callback = r;
 return m;
}

public final boolean sendmessagedelayed(message msg, long delaymillis)
{
 if (delaymillis < 0) {
  delaymillis = 0;
 }
 return sendmessageattime(msg, systemclock.uptimemillis() + delaymillis);
}

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);
}

private boolean enqueuemessage(messagequeue queue, message msg, long uptimemillis) {
 msg.target = this;
 if (masynchronous) {
  msg.setasynchronous(true);
 }
 return queue.enqueuemessage(msg, uptimemillis);
}

public final void removecallbacksandmessages(object token) {
 mqueue.removecallbacksandmessages(this, token);
}

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("messagequeue", 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;
}

message next() {
 // return here if the message loop has already quit and been disposed.
 // this can happen if the application tries to restart a looper after quit
 // which is not supported.
 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 (false) log.v("messagequeue", "returning message: " + msg);
     return msg;
    }
   } else {
    // no more messages.
    nextpolltimeoutmillis = -1;
   }

   // process the quit message now that all pending messages have been handled.
   if (mquitting) {
    dispose();
    return null;
   }

   // if first time idle, then get the number of idlers to run.
   // idle handles only run if the queue is empty or if the first message
   // in the queue (possibly a barrier) is due to be handled in the future.
   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)];
   }
   mpendingidlehandlers = midlehandlers.toarray(mpendingidlehandlers);
  }

  // run the idle handlers.
  // we only ever reach this code block during the first iteration.
  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("messagequeue", "idlehandler threw exception", t);
   }

   if (!keep) {
    synchronized (this) {
     midlehandlers.remove(idler);
    }
   }
  }

  // reset the idle handler count to 0 so we do not run them again.
  pendingidlehandlercount = 0;

  // while calling an idle handler, a new message could have been delivered
  // so go back and look again for a pending message without waiting.
  nextpolltimeoutmillis = 0;
 }
}

void removemessages(handler h, int what, object object) {
 if (h == null) {
  return;
 }

 synchronized (this) {
  message p = mmessages;

  // remove all messages at front.
  while (p != null && p.target == h && p.what == what
    && (object == null || p.obj == object)) {
   message n = p.next;
   mmessages = n;
   p.recycleunchecked();
   p = n;
  }

  // remove all messages after front.
  while (p != null) {
   message n = p.next;
   if (n != null) {
    if (n.target == h && n.what == what
     && (object == null || n.obj == object)) {
     message nn = n.next;
     n.recycleunchecked();
     p.next = nn;
     continue;
    }
   }
   p = n;
  }
 }
}

/**
 * return a new message instance from the global pool. allows us to
 * avoid allocating new objects in many cases.
 */
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();
}

/**
 * return a message instance to the global pool.
 * <p>
 * you must not touch the message after calling this function because it has
 * effectively been freed. it is an error to recycle a message that is currently
 * enqueued or that is in the process of being delivered to a handler.
 * </p>
 */
public void recycle() {
 if (isinuse()) {
  if (gcheckrecycle) {
   throw new illegalstateexception("this message cannot be recycled because it "
     + "is still in use.");
  }
  return;
 }
 recycleunchecked();
}

/**
 * recycles a message that may be in-use.
 * used internally by the messagequeue and looper when disposing of queued messages.
 */
void recycleunchecked() {
 // mark the message as in use while it remains in the recycled object pool.
 // clear out all other details.
 flags = flag_in_use;
 what = 0;
 arg1 = 0;
 arg2 = 0;
 obj = null;
 replyto = null;
 sendinguid = -1;
 when = 0;
 target = null;
 callback = null;
 data = null;

 synchronized (spoolsync) {
  if (spoolsize < max_pool_size) {
   next = spool;
   spool = this;
   spoolsize++;
  }
 }
}

public class handlerthread extends thread {
int mpriority;
int mtid = -1;
looper mlooper;

public handlerthread(string name) {
 super(name);
 mpriority = process.thread_priority_default;
}

@override
public void run() {
 mtid = process.mytid();
 looper.prepare();
 synchronized (this) {
  mlooper = looper.mylooper();
  notifyall();
 }
 process.setthreadpriority(mpriority);
 onlooperprepared();
 looper.loop();
 mtid = -1;
}

public looper getlooper() {
 if (!isalive()) {
  return null;
 }

 // if the thread has been started, wait until the looper has been created.
 synchronized (this) {
  while (isalive() && mlooper == null) {
   try {
    wait();
   } catch (interruptedexception e) {
   }
  }
 }
 return mlooper;
}

public boolean quit() {
 looper looper = getlooper();
 if (looper != null) {
  looper.quit();
  return true;
 }
 return false;
}
}