发现无论是Windows还是Android，它们都是利用消息机制来运行一个程序，使得程序能够持久的运行下去，那它们之间都有共同的特点，都属于CS端
那么为了更好的深入理解android的消息机制，我打算手写一个Java版的Handler来模拟Android程序运行
1.首先我创建了一些空白类，其中Main类是我们程序的入口
2.接着我们开始手写Looper
在Looper中我们知道有两个非常重要的方法prepare()和loop()，在sdk中找到相关源码，提取关键，形成一份精简的代码
/**
* Created by ccwant on 2019-01-10.
*/
public class Looper {
private static final String TAG = "Looper";
private static Looper sMainLooper; // guarded by Looper.class
static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
final MessageQueue mQueue;
final Thread mThread;
private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}
/**
* 将当前线程初始化为循环器，并将其标记为
* 应用程序的主环。应用程序的主循环器
* 由Android环境创建，因此您不应该需要
* 自行调用此函数。另请参见：@link prepare（）
*/
public static void prepareMainLooper() {
prepare(false);
synchronized (Looper.class) {
if (sMainLooper != null) {
throw new IllegalStateException("The main Looper has already been prepared.");
}
sMainLooper = myLooper();
}
}
public static Looper getMainLooper() {
synchronized (Looper.class) {
return sMainLooper;
}
}
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");
}
Log.d(TAG,"创建了一个新的Looper");
sThreadLocal.set(new Looper(quitAllowed));
}
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();
}
}
public static Looper myLooper() {
return sThreadLocal.get();
}
}3.手写MeesageQueue
同样，在MeesageQueue中也有两个非常重要的方法next()和enqueueMessage()，分别用于读取消息和插入新消息
import java.util.ArrayList;
/**
* Created by ccwant on 2019-01-10.
*/
public class MessageQueue {
private static final String TAG = "MessageQueue";
// True if the message queue can be quit.
private final boolean mQuitAllowed;
Message mMessages;
private final ArrayList<IdleHandler> mIdleHandlers = new ArrayList<IdleHandler>();
private IdleHandler[] mPendingIdleHandlers;
private boolean mQuiting;
// Indicates whether next() is blocked waiting in pollOnce() with a non-zero timeout.
private boolean mBlocked;
MessageQueue(boolean quitAllowed) {
Log.d(TAG,"初始化消息队列");
mQuitAllowed = quitAllowed;
}
Message next() {
int pendingIdleHandlerCount = -1; // -1 only during first iteration
int nextPollTimeoutMillis = 0;
for (; ; ) {
synchronized (this) {
// Try to retrieve the next message. Return if found.
final long now = System.currentTimeMillis();
final Message msg = mMessages;
if (msg != null) {
final long when = msg.when;
if (now >= when) {
mBlocked = false;
mMessages = msg.next;
msg.next = null;
Log.d(TAG, "Returning message: " + msg);
msg.markInUse();
return msg;
} else {
nextPollTimeoutMillis = (int) Math.min(when - now, Integer.MAX_VALUE);
}
} else {
nextPollTimeoutMillis = -1;
}
// If first time, then get the number of idlers to run.
if (pendingIdleHandlerCount < 0) {
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.d("MessageQueue", "IdleHandler threw exception");
}
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;
}
}
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.");
}
final boolean needWake;
synchronized (this) {
if (mQuiting) {
RuntimeException e = new RuntimeException(
msg.target + " sending message to a Handler on a dead thread");
Log.w("MessageQueue", e.getMessage());
return false;
} else if (msg.target == null) {
mQuiting = true;
}
msg.when = when;
Log.d("MessageQueue", "Enqueing: " + msg);
Message p = mMessages;
if (p == null || when == 0 || when < p.when) {
msg.next = p;
mMessages = msg;
needWake = mBlocked; // new head, might need to wake up
} else {
Message prev = null;
while (p != null && p.when <= when) {
prev = p;
p = p.next;
}
msg.next = prev.next;
prev.next = msg;
needWake = false; // still waiting on head, no need to wake up
}
}
if (needWake) {
//nativeWake(mPtr);
}
return true;
}
private void dispose() {
}
/**
* 用于发现线程何时阻塞的回调接口
* 等待更多消息
*/
public static interface IdleHandler {
/**
* 当消息队列中的消息用完时调用，现在将
* 等待更多信息。返回true以保持空闲处理程序处于活动状态，返回false
* 将其移除。如果仍有消息，则可以调用此函数
* 在队列中挂起，但它们都计划调度
* 在当前时间之后。
*/
boolean queueIdle();
}
}
4.手写Message对象
这里Message是一个实体类，我们通常使用它来传递消息对象，在这个地方我们同样精简化
import java.io.Serializable;
/**
* Created by ccwant on 2019-01-10.
*/
public class Message implements Serializable {
public int what;
public Object obj;
public int sendingUid = -1;
/**
* 如果正在使用set message。
* 此标志在消息排队时设置，在消息排队时保持设置状态。
* 交付后再回收。该标志只被清除
* 当创建或获取新消息时，因为这是唯一一次
* 允许应用程序修改消息的内容。
* 试图排队或回收已在使用的邮件是一个错误。
*/
static final int FLAG_IN_USE = 1 << 0;
/**
* 如果设置消息是异步的
*/
static final int FLAG_ASYNCHRONOUS = 1 << 1;
/**
* 在CopyFrom方法中要清除的标志
*/
static final int FLAGS_TO_CLEAR_ON_COPY_FROM = FLAG_IN_USE;
int flags;
long when;
Handler target;
Runnable callback;
Message next;
private static final Object sPoolSync = new Object();
private static Message sPool;
private static int sPoolSize = 0;
private static final int MAX_POOL_SIZE = 50;
private static boolean gCheckRecycle = true;
/**
* 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();
}
public boolean isAsynchronous() {
return (flags & FLAG_ASYNCHRONOUS) != 0;
}
void markInUse() {
flags |= FLAG_IN_USE;
}
public void setAsynchronous(boolean async) {
if (async) {
flags |= FLAG_ASYNCHRONOUS;
} else {
flags &= ~FLAG_ASYNCHRONOUS;
}
}
/*package*/ boolean isInUse() {
return ((flags & FLAG_IN_USE) == FLAG_IN_USE);
}
public void recycle() {
if (isInUse()) {
if (gCheckRecycle) {
throw new IllegalStateException("This message cannot be recycled because it "
+ "is still in use.");
}
return;
}
recycleUnchecked();
}
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;
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++;
}
}
}
@Override
public String toString() {
return "Message{" +
"what=" + what +
", obj=" + obj +
'}';
}
}
5.手写Handler
精简Handler，提取关键方法sendMessage()
import java.lang.reflect.Modifier;
/**
* Created by ccwant on 2019-01-10.
*/
public class Handler {
private static final boolean FIND_POTENTIAL_LEAKS = false;
private static final String TAG = "Handler";
private static Handler MAIN_THREAD_HANDLER = null;
final Looper mLooper;
final MessageQueue mQueue;
final Callback mCallback;
final boolean mAsynchronous;
public Handler() {
this(null, false);
}
public Handler(Callback callback) {
this(callback, false);
}
public Handler(Looper looper) {
this(looper, null, false);
}
public Handler(boolean async) {
this(null, async);
}
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) {
System.out.println("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;
}
public Handler(Looper looper, Callback callback, boolean async) {
mLooper = looper;
mQueue = looper.mQueue;
mCallback = callback;
mAsynchronous = async;
}
public final boolean sendMessage(Message msg) {
return sendMessageDelayed(msg, 0);
}
public final boolean sendMessageDelayed(Message msg, long delayMillis) {
if (delayMillis < 0) {
delayMillis = 0;
}
return sendMessageAtTime(msg, System.currentTimeMillis() +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.e(TAG,e.getMessage());
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 void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}
public void handleMessage(Message msg) {
}
private static void handleCallback(Message message) {
message.callback.run();
}
public interface Callback {
public boolean handleMessage(Message msg);
}
}
6.到这里基本框架已经完成，紧接着我们模拟一下Android程序的运行
import com.ccwant.sys.Handler;
import com.ccwant.sys.Log;
import com.ccwant.sys.Looper;
import com.ccwant.sys.Message;
public class Main {
private static final String TAG = "Main";
public static void main(String[] args) {
Log.d(TAG, "主线程：" + Thread.currentThread().getName());
Looper.prepareMainLooper();
new Application().main();
Looper.loop();
}
private static class Application{
private static final String TAG = "Application";
public void main(){
Log.d(TAG, "Application create.");
startActivity();
}
private void startActivity(){
Activity activity = new Activity();
activity.onCreate();
}
}
private static class Activity{
private static final String TAG = "Activity";
Handler mHandler = new Handler(new Handler.Callback() {
@Override
public boolean handleMessage(Message msg) {
Log.d(TAG, "当前线程：" + Thread.currentThread().getName());
Log.d(TAG, "拦截消息：" + msg.obj);
return false;
}
});
public void onCreate(){
Log.d(TAG, "onCreate");
sendTest();
}
private void sendTest(){
new Thread(new Runnable() {
@Override
public void run() {
//Looper.prepare();
for (int i = 0; i < 2; i++) {
Log.d(TAG, "-----------");
Message msg = new Message();
msg.obj = "123";
msg.what = 1;
Log.d(TAG, "准备发送：" +msg+" 当前线程:"+Thread.currentThread().getName());
mHandler.sendMessage(msg);
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}).start();
}
}
}
我们想一下，Android中我们知道有个主线程，UI的绘制全部是在主线程中运行，如果主线程结束，那么程序也就停止了。
这个主线程究竟是怎么运行起来的？
在这里，Looper起到了重大的作用，在Looper中的loop()方法，通过无限循环不断的读取消息，分发消息，从而保证程序的正常运行
讲到这里，我又翻了一下Android源码，在android.app.ActivityThread类中找到了入口main方法
估计说到这里，有人会问：loop()的无限循环岂不是特别耗CPU资源？
其实不然，这里就涉及到Linux pipe/epoll机制，简单说就是在主线程的MessageQueue没有消息时，便阻塞在loop的queue.next()中的nativePollOnce()方法里，此时主线程会释放CPU资源进入休眠状态，直到下个消息到达或者有事务发生，通过往pipe管道写端写入数据来唤醒主线程工作。这里采用的epoll机制，是一种IO多路复用机制，可以同时监控多个描述符，当某个描述符就绪(读或写就绪)，则立刻通知相应程序进行读或写操作，本质同步I/O，即读写是阻塞的。 所以说，主线程大多数时候都是处于休眠状态，并不会消耗大量CPU资源
还有人可能会问：Activity的生命周期是怎么实现在死循环体外能够执行起来的？
ActivityThread的内部类H继承于Handler，通过handler消息机制，简单说Handler机制用于同一个进程的线程间通信。
Activity的生命周期都是依靠主线程的Looper.loop，当收到不同Message时则采用相应措施：
在H.handleMessage(msg)方法中，根据接收到不同的msg，执行相应的生命周期。
比如收到msg=H.LAUNCH_ACTIVITY，则调用ActivityThread.handleLaunchActivity()方法，最终会通过反射机制，创建Activity实例，然后再执行Activity.onCreate()等方法； 再比如收到msg=H.PAUSE_ACTIVITY，则调用ActivityThread.handlePauseActivity()方法，最终会执行Activity.onPause()等方法。
上述过程，我只挑核心逻辑讲，真正该过程远比这复杂。主线程的消息又是哪来的呢？
当然是App进程中的其他线程通过Handler发送给主线程，请看接下来的内容：
最后，从进程与线程间通信的角度，通过一张图加深大家对App运行过程的理解：
system_server进程是系统进程，java framework框架的核心载体，里面运行了大量的系统服务，比如这里提供ApplicationThreadProxy（简称ATP），ActivityManagerService（简称AMS），这个两个服务都运行在system_server进程的不同线程中，由于ATP和AMS都是基于IBinder接口，都是binder线程，binder线程的创建与销毁都是由binder驱动来决定的。
App进程则是我们常说的应用程序，主线程主要负责Activity/Service等组件的生命周期以及UI相关操作都运行在这个线程； 另外，每个App进程中至少会有两个binder线程 ApplicationThread(简称AT)和ActivityManagerProxy（简称AMP），除了图中画的线程，其中还有很多线程，比如signal catcher线程等，这里就不一一列举。
Binder用于不同进程之间通信，由一个进程的Binder客户端向另一个进程的服务端发送事务，比如图中线程2向线程4发送事务；而handler用于同一个进程中不同线程的通信，比如图中线程4向主线程发送消息。
结合图说说Activity生命周期，比如暂停Activity，流程如下：
1.线程1的AMS中调用线程2的ATP；（由于同一个进程的线程间资源共享，可以相互直接调用，但需要注意多线程并发问题）
2.线程2通过binder传输到App进程的线程4；
3.线程4通过handler消息机制，将暂停Activity的消息发送给主线程；
4.主线程在looper.loop()中循环遍历消息，当收到暂停Activity的消息时，便将消息分发给ActivityThread.H.handleMessage()方法，再经过方法的调用，最后便会调用到Activity.onPause()，当onPause()处理完后，继续循环loop下去。
672
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
