备注：水平一般，欢迎指正

概述：

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

Android中的Thread, Looper和Handler机制