目录
消息机制的引入
系统中的UI控件不是线程安全,而使用锁机制来实现同步会影响UI控件的执行效率。故系统规定只能在主线程中进行UI进行(参看下面代码的校验)，采用单线程模型来处理UI操作。同时提供Handler消息机制来进行线程间的通信。
//ViewRootImpl类中对UI操作进行了线程校验
void checkThread() {
if (mThread != Thread.currentThread()) {
throw new CalledFromWrongThreadException(
"Only the original thread that created a view hierarchy can touch its views.");
}
}
消息机制的主要成员
1，Message消息：用于携带数据的一种对象元素。常用成员：
what：常用于区分不同的消息
obj ：常用携带需要传递的数据
target ：用于标记消息来源的Handler
callback ： 用于记录使用post方法发送的Runnable任务
2，MessageQueue消息队列：采用单链表结构存储消息队列。用于接收并保持Handler发送的消息，同时提供给Loop进行消息的查询
3，Loop：以无限循环的方法遍历查询MessageQueue中是否有消息并且消息执行的时间与当前吻合，然后将消息通过target 标记分发给对应的Handler进行执行相应的操作
主线程中默认在ActivityThread的main()方法中创建了mainLoop对象。调用方法： Looper.prepareMainLooper();与Looper.loop(); 同时主线程中创建了名称为H的Handler进行四大组件的生命周期的处理。
public static void main(String[] args) {
```
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");
}
4，ThreadLocal：是一个线程内部的数据存储类，其数据的作用域为当前的线程，恰好用来保存Loop对象，获取Loop对象。
5，Handler：消息机制的核心，用于发送消息，接收消息并进行相应的逻辑处理。
工作流程与原理
1，创建Handler对象的方式：
//没有覆写handleMessage()方法,针对post(Runnable r)的方式发送消息
Handler handler1 = new Handler();
//针对sendMessage()方式的发送消息
Handler handler2 = new Handler() {
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
//处理接收到消息后的逻辑
}
};
//
Handler handler3 = new Handler(new Handler.Callback() {
@Override
public boolean handleMessage(Message msg) {
//处理接收到消息后的逻辑
return false;
}
});
2，消息的产生：三种方式。
//直接创建消息对象
Message message1 = new Message();
//先从消息池中获取,默认最大50条消息,当消息池获取不到才创建,推荐使用这种方式
Message message2 = Message.obtain();
//最后还是调用Message.obtain()方法
Message message3 = handler.obtainMessage();
//Message中obtain方法的源码
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();
}
3，发送消息的两种方式：
//直接在Runnable中处理逻辑,一般用于在同一线程中进行延时操作
handler.postDelayed(runnable, 100);
//一般用于不同线程之间,在Handler的handleMessage()方法中处理收到消息的逻辑
handler.sendMessage(message2);
//最终所有的方式,包含延时与不延时都会调用统一方法：enqueueMessage（），将消息插入MessageQueue队列中
//Handler的不同调用方式最终统一到此方法中
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
msg.target = this; //this : 代表当前发送消息的Handler,最后分发消息时判断。
if (mAsynchronous) {
msg.setAsynchronous(true);
}
return queue.enqueueMessage(msg, uptimeMillis);
}
//MessageQueue中将消息插入队列的方法
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;
}
4，Loop遍历消息并分发给对应的Handler：调用Loop.loop()方法
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;
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对象就是发送当前消息的Handler，然后返回到Handler的dispatchMessage（）中进行消息处理方法的分发。
msg.target.dispatchMessage(msg);
if (logging != null) {
logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);
}
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.recycle();
}
}
5，Handler中根据不同类型的发送方式与创建方式，分发到具体的方法中执行接收后的逻辑。
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
//当发送消息是以post(Runnable r)的方式时,调用此方法,直接执行Runnable的run()方法
handleCallback(msg);
} else {
if (mCallback != null) {
//回调到Handler的handleMessage中进行接收逻辑的处理
if (mCallback.handleMessage(msg)) {
return;
}
}
//回调到Handler的handleMessage中进行接收逻辑的处理
handleMessage(msg);
}
}
//执行Runnable的run()方法
private static void handleCallback(Message message) {
message.callback.run();
}
6，子线程中能够创建Handler？
子线程中是可以创建Handler的，但必须在创建Handler之前调用方法：
Looper.prepare();与Looper.loop();
7，一个线程中能否有多个：Loop，MessageQueue，Handler？
一个线程中只能有一个Loop与MessageQueue，但可以有多个Handelr。
8，Android中为什么主线程不会因为Looper.loop()里的死循环卡死？
参考知乎上的回答 : https://www.zhihu.com/question/34652589
Android中关联类
1，AsyncTask：用于异步处理的类，封装了Handler与两个线程池（SERIAL_EXECUTOR：用于任务排队；THREAD_POOL_EXECUTOR：用于真正的执行任务）。主要方法：
1，execute（），传入可变参数，类型为第一个泛型。同时也是执行的入口
2，onPreExecute（）：用于执行一些准备工作，在主线程中，优先执行于doInBackground（）
3，doInBackground（）：参数为传入的第一类泛型，在后台执行耗时的操作
4，onProgressUpdate（）：显示执行任务的进度，参数为第二类泛型。需要在doInBackground（）中调用方法：publishProgress（）才能执行。
5，onPostExecute（）：参数为第三类泛型，对应doInBackground（）执行后的返回结果，在主线程中进行，执行UI的操作。
2，HandlerThread：继承了Thread，内部创建了Loop对象。可以在主线程创建Handler时传入该Loop，从而使Handler的执行在HandlerThread线程。
HandlerThread thread = new HandlerThread("子线程");
thread.start();
Handler handler = new Handler(thread.getLooper()){
@Override
public void handleMessage(Message msg) {
Log.d(TAG, "handleMessage: " + msg.what + " ;; " + Thread.currentThread().getName());
}
};
handler.sendEmptyMessage(1);
//打印结果：在子线程中执行的Handler消息
10-21 17:41:35.386 27530-27626/com.learn.study D/MainActivity: handleMessage: 1 ;; 子线程
3，IntentService：继承Service，内部封装了Handler的实现。使用时需要在onHandleIntent（）中实现收到消息后的逻辑处理。同时也利用了HandlerThread在服务中开启子线程。适合于执行一些高优先级的后台任务。
//在onCreate()中创建Handler
public void onCreate() {
super.onCreate();
//创建一个子线程
HandlerThread thread = new HandlerThread("IntentService[" + mName + "]");
thread.start();
//创建一个在子线程中执行的Handler
mServiceLooper = thread.getLooper();
mServiceHandler = new ServiceHandler(mServiceLooper);
}
//在onStart()中发送消息
public void onStart(Intent intent, int startId) {
Message msg = mServiceHandler.obtainMessage();
msg.arg1 = startId;
msg.obj = intent;
mServiceHandler.sendMessage(msg);
}
//执行Handler接收到消息后的逻辑处理，覆写该方法时自己处理。
protected abstract void onHandleIntent(Intent intent);
//任务完成后会自动关闭,调用stopSelf()
public final void stopSelf(int startId) {
if (mActivityManager == null) {
return;
}
try {
//最终调用系统IActivityManager的方法。
mActivityManager.stopServiceToken(new ComponentName(this, mClassName), mToken, startId);
} catch (RemoteException ex) {
}
}
网友评论