备注：水平一般，欢迎指正
概述：
Looper和Handler就是为了线程间通信。
使用：
public class MyHandleThread extends Thread {
private static final String TAG = "MyHandleThread";
public Handler handler = null;
@Override
public void run() {
Log.e(TAG,"进入Thread的run");
Looper.prepare();
handler = new Handler(Looper.myLooper()) {
@Override
public void handleMessage(Message msg) {
Log.e(TAG,"获得Message == " + msg.obj);
super.handleMessage(msg);
}
};
Looper.loop();
}
}
使用
public class HandlerThreadFragment extends Fragment implements View.OnClickListener{
private static final String TAG = "AsyncTaskFragment";
private View rootView;
private Button btnThreadHander;
private Button btnSendMessage;
private MyHandleThread handleThread;
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
Bundle savedInstanceState) {
return inflater.inflate(R.layout.fragment_async_task, container, false);
}
@Override
public void onStart() {
super.onStart();
rootView = getView();
btnThreadHander = rootView.findViewById(R.id.handlerThread);
btnThreadHander.setOnClickListener(this);
btnSendMessage = rootView.findViewById(R.id.sendMessage);
btnSendMessage.setOnClickListener(this);
}
@Override
public void onClick(View v) {
switch (v.getId()) {
case R.id.handlerThread:
handleThread = new MyHandleThread();
handleThread.start();
break;
case R.id.sendMessage:
Message msg = new Message();
msg.obj = "haha";
handleThread.handler.sendMessage(msg);
handleThread.handler.post(new Runnable() {
@Override
public void run() {
Log.e(TAG,"执行runnable");
}
});
break;
}
}
}
源码分析
一. 为什么A线程发送消息，在B线程中执行：
// Looper.prepare() || Looper.loop();
在B线程中循环从MessageQueue中遍历获取消息。
// handler.sendMessage(Message msg)
将消息发送到B线程所绑定的Looper所绑定的MessageQueue中，之后B线程获取消息，交由Handler处理
参考：
ThreadLocal
// ### Looper.java
static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
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");
}
// 创建绑定当前线程的Looper
sThreadLocal.set(new Looper(quitAllowed));
}
// 线程进入循环遍历消息，
private Looper(boolean quitAllowed) {
// 创建MessageQueue,和Looper绑定
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}
public static void loop() {
final Looper me = myLooper();
.....
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;
}
............
final long start = (slowDispatchThresholdMs == 0) ? 0 : SystemClock.uptimeMillis();
final long end;
try {
// 开始处理消息
msg.target.dispatchMessage(msg);
end = (slowDispatchThresholdMs == 0) ? 0 : SystemClock.uptimeMillis();
} finally {
}
.........
msg.recycleUnchecked();
}
}
// ### Handler.java {处理消息}
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
// 发送msg进入到队列中，再由Handler处理消息
handleMessage(msg);
}
}
// ### Message.java
// 成员变量
/*package*/ Handler target;
// 单链表
/*package*/ Message next;
// ### handler.java
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
// Message持有发送它的Handler对象
msg.target = this;
if (mAsynchronous) {
msg.setAsynchronous(true);
}
return queue.enqueueMessage(msg, uptimeMillis);
}
二. 如何保证线程安全：
A线程 发送消息到 B线程
A线程把消息放入到MessageQueue中，
B线程把消息从MessageQueue中取出，处理消息。
通过加锁{synchronized},锁的是当前对象，来保证进出队列的数据安全。
参考：
synchronized机制
①. 放入消息队列：
boolean enqueueMessage(Message msg, long when) {
....
// 加锁，锁的是当前对象
synchronized (this) {
.....
msg.markInUse();
msg.when = when;
// mMessages 消息队列的头节点
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 {
........
// 以下代码：将消息放入队尾
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() {
..........
for (;;) {
......
synchronized (this) {
........
Message prevMsg = null;
Message msg = mMessages;
if (msg != null) {
// 将队列中头节点，从队列中取出来。
mMessages = msg.next;
msg.next = null;
msg.markInUse();
return msg;
}
}
}
}
