Handler消息机制

App中一般多会有多个线程，多线程之间难免需要进行通信。开发中线程通信用的最多的就是Handler，另外还有，例如子线程进行数据处理，在主线程中进行UI更新。

当然了除了Handler这种通信方式外，线程间的通信还有其他几种方式：管道Pip、共享内存、通过文件及数据库等。

一，基础介绍

1.使用Handler

如何使用Handler呢，很简单看代码：

public class TextActivity extends AppCompatActivity {
    private Handler handler;
    private Handler handler1;
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        handler = new Handler();
        new Thread(new Runnable() {
            @Override
            public void run() {
                Log.e("TextActivity", "run: " );
               handler1=new Handler();
            }
        }).start();

    }
}

上边的代码，运行结果

handler成功创建了，handler1出现了异常，说是没有Looper。只需要在添加一行代码就可以了。Looper.prepare()方法就是创建了一个Looper。

            @Override
            public void run() {
                Log.e("TextActivity", "run: " );
                //创建Looper
                Looper.prepare();
                handler1=new Handler();
            }

Looper.prepare()方法到底做了什么呢，我们先来看看抛异常的代码如下：

    public Handler(@Nullable Callback callback, boolean async) {
      
        mLooper = Looper.myLooper();
        if (mLooper == null) {
            throw new RuntimeException(
                "Can't create handler inside thread " + Thread.currentThread()
                        + " that has not called Looper.prepare()");
        }
        mQueue = mLooper.mQueue;
        mCallback = callback;
        mAsynchronous = async;
    }

上边代码可以看出当我们创建Handler的时候，如果没有取到Looper就会抛异常。

那么Looper.prepare()又执行了啥呢，其实就是创建了一个Looper，保存在了sThreadLocal中。ThreadLocal是线程隔离的，所以一个线程对应一个Looper。

    static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
    
    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));
    }

为什么在主线程中创建Handler没有问题呢，那就先从ActivityThread中去找，在main函数中，我们看到了Looper.prepareMainLooper()，这行代码就是创建了一个主线程的Looper。

    public static void main(String[] args) {
     
        // Call per-process mainline module initialization.
        initializeMainlineModules();

        Process.setArgV0("<pre-initialized>");
        //创建主线程looper
        Looper.prepareMainLooper();

        //开启消息循环
        Looper.loop()
        
        ...省略
}

2.开发中的问题

当我们创建一个Handler时，会存在内存泄漏的问题。因为内部类会持有外部类的引用，我们在Activity中创建Handler，Activity被销毁时由于Handler可能存在延时任务依然持有引用，就导致GC无法回收Activity。

通常的处理办法是静态内部类+弱引用。另外在页面退出的时候，调用相应的Handler的removeCallbacks()方法，把消息对象从消息队列移除就行了。

    protected static class BaseHandler extends Handler {
        private final WeakReference<BaseMvpActivity> mObjects;

        public BaseHandler(BaseMvpActivity mPresenter) {
            mObjects = new WeakReference<>(mPresenter);
        }

        @Override
        public void handleMessage(Message msg) {
            BaseMvpActivity mPresenter = mObjects.get();
            if (mPresenter != null)
                mPresenter.handleMessage(msg);
        }
    }

二，消息机制

在使用Handler发送消息的时候，会涉及到这几个类，Looper，MessageQueue，Handler，Message。

1.Looper

看下Looper的成员变量

public final class Looper {

    //用于存放创建的Looper，ThreadLocal是线程隔离的一个类。一个线程对应一个Looper。
    @UnsupportedAppUsage
    static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
    @UnsupportedAppUsage
    private static Looper sMainLooper;  // guarded by Looper.class
    private static Observer sObserver;

    @UnsupportedAppUsage
    final MessageQueue mQueue;
    final Thread mThread;
    
    ...省略
}

创建Looper的方法

    private static void prepare(boolean quitAllowed) {
        // 规定了一个线程只有一个Looper，也就是一个线程只能调用一次Looper.prepare()
        if (sThreadLocal.get() != null) {
            throw new RuntimeException("Only one Looper may be created per thread");
        }
        // 如果当前线程没有Looper，那么就创建一个，存到sThreadLocal中 
        sThreadLocal.set(new Looper(quitAllowed));
    }

开始运行消息循环：这是的消息循环是个死循环，为什么不会导致应用卡死。

这里就涉及到Linux pipe/epoll机制，简单说就是在主线程的MessageQueue没有消息时，便阻塞在loop的queue.next()中的nativePollOnce()方法里，此时主线程会释放CPU资源进入休眠状态，直到下个消息到达或者有事务发生，通过往pipe管道写端写入数据来唤醒主线程工作。这里采用的epoll机制，是一种IO多路复用机制，可以同时监控多个描述符，当某个描述符就绪(读或写就绪)，则立刻通知相应程序进行读或写操作，本质同步I/O，即读写是阻塞的。所以说，主线程大多数时候都是处于休眠状态，并不会消耗大量CPU资源。

poop()方法是开启消息循环的，主线的loop()方法运行在ActivityThead#mian方法中。

    public static void loop() {
        final Looper me = myLooper();
  
        me.mSlowDeliveryDetected = false;

        for (;;) {
            if (!loopOnce(me, ident, thresholdOverride)) {
                return;
            }
        }
    }

接下来看Looper的构造方法：

    private Looper(boolean quitAllowed) {
        // 创建了MessageQueue，并供Looper持有 
        mQueue = new MessageQueue(quitAllowed);
        // 让Looper持有当前线程对象 
        mThread = Thread.currentThread();
    }

创建了消息队列MessageQueue，并让它供Looper持有，因为一个线程最大只有一个Looper对象，所以一个线程最多也只有一个消息队列。

2.MessageQueue

消息队列，存放了Handler发送的消息，供Looper循环取消息。

public final class MessageQueue {
    private static final String TAG = "MessageQueue";
    private static final boolean DEBUG = false;

    // True if the message queue can be quit.
    @UnsupportedAppUsage
    private final boolean mQuitAllowed;
    //消息实体
    Message mMessages;
    //存放IdleHandler
    private final ArrayList<IdleHandler> mIdleHandlers = new ArrayList<IdleHandler>();
    private SparseArray<FileDescriptorRecord> mFileDescriptorRecords;
    private IdleHandler[] mPendingIdleHandlers;
    private boolean mQuitting;

IdleHandler是一个只有一个方法的接口：

public static interface IdleHandler {
        boolean queueIdle();
 }

queueIdle方法会在MessageQueue中当前没有消息需要执行（Message空了或者下一个Message还要等一会儿才到执行时间）之后回调，方法的返回值是一个boolean值：当返回值为false时，MessageQueue会删除掉这个IdleHandler，之后不会再调用到这个对象。反之则继续持有这个对象，在下次空闲时再调用一次。

你在开发中这样用过吗？

        Looper.myQueue().addIdleHandler(new MessageQueue.IdleHandler() {
            @Override
            public boolean queueIdle() {

                return false;
            }
        });

最后在next方法中，没有message可执行的情况下调用：

    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 (;;) {
            ...省略
            //最后才执行
            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(TAG, "IdleHandler threw exception", t);
                }

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

        }
    }

源码中有一处地方用到了：在ActivityThread中通过IdleHandler来在空闲时调用GC，来减少卡顿的可能性：

 void scheduleGcIdler() {
        if (!mGcIdlerScheduled) {
            mGcIdlerScheduled = true;
            Looper.myQueue().addIdleHandler(mGcIdler);
        }
        mH.removeMessages(H.GC_WHEN_IDLE);
    }
 final class GcIdler implements MessageQueue.IdleHandler {
        @Override
        public final boolean queueIdle() {
            doGcIfNeeded();
            purgePendingResources();
            return false;
        }
    }

同步屏障

这里的同步并不是多线程中线程安全的那个同步，而是指，一个MessageQueue中的所有message的执行顺序的同步，即默认情况下所有message都是同步的，所有message按when排序，依次执行。而如果某些message优先级非常高，我们想让它在特定时间后尽早执行，应该怎么办呢？这时候就是同步屏障的用武之地了。
同步屏障功能的实现分为两个部分：
1：插入一个同步屏障，使同步屏障之后的同步message暂停执行；
2：插入异步message。

首先看插入同步屏障的方式，我们插入同步屏障的方法是调用MessageQueue#postSyncBarrier方法：

public int postSyncBarrier() {
     return postSyncBarrier(SystemClock.uptimeMillis());
}

private int postSyncBarrier(long when) {
    // Enqueue a new sync barrier token.
    // We don't need to wake the queue because the purpose of a barrier is to stall it.
    synchronized (this) {
        final int token = mNextBarrierToken++;
        final Message msg = Message.obtain();
        msg.markInUse();
        msg.when = when;
        msg.arg1 = token;

        Message prev = null;
        Message p = mMessages;
        if (when != 0) {
            while (p != null && p.when <= when) {
                prev = p;
                p = p.next;
            }
        }
        if (prev != null) { // invariant: p == prev.next
            msg.next = p;
            prev.next = msg;
        } else {
            msg.next = p;
            mMessages = msg;
        }
        return token;
    }
}
public void removeSyncBarrier(int token) {
	// Remove a sync barrier token from the queue.
	 // If the queue is no longer stalled by a barrier then wake it.
	 synchronized (this) {
	     Message prev = null;
	     Message p = mMessages;
	     while (p != null && (p.target != null || p.arg1 != token)) {//遍历任务队列
	         prev = p;
	         p = p.next;
	     }
	     if (p == null) { //没有找到token对应的同步屏障，抛出异常
	         throw new IllegalStateException("The specified message queue synchronization "
	                 + " barrier token has not been posted or has already been removed.");
	     }
	     final boolean needWake;
	     if (prev != null) {
	         prev.next = p.next; //从队列中移除同步屏障
	         needWake = false;
	     } else {
	         mMessages = p.next;
	         needWake = mMessages == null || mMessages.target != null;
	     }
	     p.recycleUnchecked();
	
	     // If the loop is quitting then it is already awake.
	     // We can assume mPtr != 0 when mQuitting is false.
	     if (needWake && !mQuitting) {
	         nativeWake(mPtr);
	     }
 	 }
 }

postSyncBarrier会按照when的值，在消息队列中插入一个target为null的message，因为when的默认值是SystemClock.uptimeMillis()当前时间，所以可以想象，这个同步屏障大多数时候都会插入到队列头部。同时需要注意，这个方法是hide的，所以我们正常情况下调用不了。postSyncBarrier会返回一个token，后续可以通过removeSyncBarrier方法并传入这个token来删除相应的同步屏障。

3.Handler

在我们用Handler发送一条消息后，最终会调用：

    public boolean sendMessageAtTime(@NonNull 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);
    }

最终调用了MessageQueue中的enqueueMessage方法：

    boolean enqueueMessage(Message msg, long when) {
        if (msg.target == null) {
            throw new IllegalArgumentException("Message must have a target.");
        }

        synchronized (this) {
            // 一个Message，只能发送一次 
            if (msg.isInUse()) {
                throw new IllegalStateException(msg + " This message is already in use.");
            }

            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 {
                // 根据需要把消息插入到消息队列的合适位置，通常是调用xxxDelay方法，延时发送消息 
                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;
            }

            // 如果队列阻塞了，则唤醒 
            if (needWake) {
                nativeWake(mPtr);
            }
        }
        return true;
    }

首先，判断了Message是否已经使用过了，如果使用过，则直接抛出异常，这是可以理解的，如果MessageQueue中已经存在一个Message，但是还没有得到处理，这时候如果再发送一次该Message，可能会导致处理前一个Message时，出现问题。

然后，会判断when，它是表示延迟的时间，我们这里没有延时，所以为0，满足if条件。把消息插入到消息队列的头部。如果when不为0，则需要把消息加入到消息队列的合适位置。

最后会去判断当前线程是否已经阻塞了，如果阻塞了，则需要调用本地方法去唤醒它。

总结：

三，面试题

1.android中实现多线程通信的方法？

view.post，activity.runOnUiThread，AsyncTask这些方式内部都是用了Handler。

2.系统为什么不允许在子线程中访问UI？

• View不是线程安全的，加上锁机制会让UI访问的逻辑变得复杂。
• 锁机制会降低UI访问的效率，因为锁机制会阻塞某些线程的执行。

3.在子线程发送消息，却能够在主线程接收消息，主线程和子线程是怎么样切换的？

这个问题很好回答，我们分两种情况，主要看Handler中的Looper是谁的looper。如果是主线程持的looper，那么就可以切换回主线程。如果是子线程looper，是不可以的。
①，第一种情况：持有主线程的Looper

        mBtn.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                //第一种情况 由于handler在主线程创建的，被主线程持有，这里只是在子线程调用handler，所以不存在严格意义上的线程切换。因此发送消息的loop()方法在主线程执行的。
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        //Handler在主线程中创建的
                        handler.sendEmptyMessage(0);
                    }
                }).start();
                //第二种情况 这里是在子线程中创建Handler，理论上这个Handler被子线程持有，但这里传入了一个getMainLooper()，这是主线程的loop。发送消息也是在主线程执行的。
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        Handler handler1 = new Handler(Looper.getMainLooper());
                        Looper.loop();
                        Log.e(TAG, "run: handler1=" + handler1.getLooper());
                        handler1.post(new Runnable() {
                            @Override
                            public void run() {
                                mBtn.setText("第二种情况");
                            }
                        });
                    }
                }).start();
            }
        });

②，第二种情况：持有子线程的Looper

下边代码抛异常了，因为looper运行在主线程中。

        mBtn.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {

                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        Looper.prepare();
                        Handler handler1 = new Handler();
                        Log.e(TAG, "run: handler1=" + handler1.getLooper());
                        handler1.post(new Runnable() {
                            @Override
                            public void run() {
                                mBtn.setText("无法更新UI，抛异常");
                            }
                        });
                        Looper.loop();
                    }
                }).start();
            }
        });

4.一个线程可以有几个Handler?几个Looper？

一个线程可以有多个Handler，但是只有一个Looper。创建Handler之前，需要创建Looper，否则会报错。

5.Handler如何实现延时任务的？

通过nativePollOnce(long ptr, int timeoutMillis)设置了定时器延迟唤醒。

nativePollOnce获取的是链表表头信息，那MessageQueue如何保证链表内获取的消息顺序从而保证执行顺序？

事实上，当调用enqueueMessage(Message msg, long when)方法，MessageQueue会根据Message的执行时间msg.when进行排序，链表头的延迟时间小，尾部延迟时间最大。

如果在延时唤醒的过程中，又来了一个立即执行的message又该如何呢？
依照上面的思路，立即执行的消息同样也会先入链表，然后唤醒线程获取表头message，看是否到了执行时间。由于立即执行的消息其实是一个延时为0的message，在一个延迟的链表中，必然会放入表头，而且是无延迟的，所以会立即取出返回给loop去执行了，loop处理完消息，继续来拿表头的message。

当整个链表都是延迟执行的message时，如果此时插入的message也是延时执行的，是否一定要唤醒呢？

如果插入的message并非插入表头，说明拿的下一个message也不是自己，完全可以让线程继续休眠，没有必要唤醒，因为此时的定时器到期唤醒后拿到的正是待返回和执行的表头message。

6.子线程可以更新UI吗？

可以更新UI，分两种情况：

①，在onCreate中直接创建线程，特殊情况

为什么下面这种方式可以呢，这里只需要做个延时就不可以了。

public class TextActivity extends AppCompatActivity {
    private Button mBtn;
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        mBtn=findViewById(R.id.btn);
        new Thread(new Runnable() {
            @Override
            public void run() {
                //Thread.sleep(2000); 加上这段代码就不行了
                mBtn.setText("你好");
            }
        }).start();
    }
}

因为检查View所在线程是在ViewRootImpl#requestLayout中进行的，而ViewRootImpl是在onResume中初始化的。

    @Override
    public void requestLayout() {
        if (!mHandlingLayoutInLayoutRequest) {
            checkThread();//检查View所在的线程
            mLayoutRequested = true;
            scheduleTraversals();
        }
    }

2，使用post方法更新UI

                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        //方式1
                        handler.post(new Runnable() {
                            @Override
                            public void run() {
                                mBtn.setText("你好");
                            }
                        });
                        //方式2
                        mBtn.post(new Runnable() {
                            @Override
                            public void run() {
                                mBtn.setText("你好");
                            }
                        });
                        //方式3
                        handler.sendEmptyMessage(0);
                        //方式4
                        runOnUiThread(new Runnable() {
                            @Override
                            public void run() {
                                mBtn.setText("你好");
                            }
                        });


                    }
                }).start();

7.Handler如何保证MessageQueue并发访问安全？

循环加锁，配合阻塞唤醒机制。

我们可以看到他的等待是在锁外的，当队列中没有消息的时候，他会先释放锁，再进行等待，直到被唤醒。这样就不会造成死锁问题了。

Message next() {
   ...
    for (;;) {
  ...
        nativePollOnce(ptr, nextPollTimeoutMillis);
        synchronized (this) {
            ...
        }
    }
} 

8.Handler的阻塞唤醒机制是怎么回事？

Handler的阻塞唤醒机制是基于Linux的阻塞唤醒机制。

这个机制也是类似于handler机制的模式。在本地创建一个文件描述符，然后需要等待的一方则监听这个文件描述符，唤醒的一方只需要修改这个文件，那么等待的一方就会收到文件从而打破唤醒。和Looper监听MessageQueue，Handler添加message是比较类似的。

9.能不能让一个Message加急被处理？/ 什么是Handler同步屏障？

可以 / 一种使得异步消息可以被更快处理的机制

Handler 同步屏障是一个用于同步线程之间消息传递的机制，它可以用于保证发送给 Handler 的消息被及时处理，从而避免消息积压导致的卡顿或崩溃问题。

总结