一篇读懂Android Handler机制

小咪咪 2024-03-22 13:19 69阅读 0赞

#### Handler简要使用说明： ####

> Handler往往使用在android中线程的通信，常见的使用是子线程给主线程发消息，然后更新UI。 但其实Handler还可以使用在任意俩个线程间的通信。

#### 1.子线程向主线程发消息： ####

private Handler mHandler = new Handler(){
        
            //重写方法接收消息
            @Override
            public void handleMessage(Message msg) {
        
                super.handleMessage(msg);
                switch (msg.what) {
        
                    //判断消息类型
                    case MESSAGE_WHAT:
                        Log.d(TAG, "主线程接收到的子线程的数据: " + ((String) msg.obj) + "   :此时我可以更新UI");
                        break;
                }
            }
        };
        private void sendMessageToMainThreadByWorkThread() {
        
            new Thread(){
        
                @Override
                public void run() {
        
                    Message message = mHandler.obtainMessage(MESSAGE_WHAT);//获取消息
                    message.obj = "我是来自工作线程的数据";
                    mHandler.sendMessage(message);//发送消息
                }
            }.start();
        }
        /*
        * 通常我们在主线程中创建一个Handler，
        * 然后重写该Handler的handlerMessage方法，可以看到该方法传入了一个参数Message，
        * 该参数就是我们从其他线程传递过来的信息。
        *
        * 我们在来看下子线程中如何传递的信息，子线程通过Handler的obtainMessage()方法获取到一个Message实例，
        * 看Message的几个属性：
        * Message.what------------------>用来标识信息的int值，通过该值主线程能判断出来自不同地方的信息来源
        * Message.arg1/Message.arg2----->Message初始定义的用来传递int类型值的两个变量
        * Message.obj------------------->用来传递任何实例化对象
        * 最后通过sendMessage将Message发送出去。
        *
        * Handler所在的线程通过handlerMessage方法就能收到具体的信息了，如何判断信息的类型呢？-->当然是通过what值咯，通过what我们就知道接收到了哪种消息，以便执行对应的操作
        * 
        */

#### `子线程与子线程的通信： 既然主线程跟子线程的通信是因为子线程持有了主线程handler的引用来发送消息给主线程，那么同理子线程A也可以通过持有子线程B的handler引用来发送消息给B线程，最后达到通信的目的` ####

如下：

private Handler handler;
        private void handlerDemoByTwoWorkThread() {
        
            Thread thread_A = new Thread() {
        
                @Override
                public void run() {
        
                    Looper.prepare(); //获取Looper对象
                    //在子线程中创建Handler
                    handler = new Handler() {
        
                        @Override
                        public void handleMessage(Message msg) {
        
                            Log.d(TAG, "thread_A 接收到消息: " + ((String) msg.obj));
                            Toast.makeText(MainActivity.this, ((String) msg.obj), Toast.LENGTH_SHORT).show();
                        }
                    };
                    Looper.loop(); //轮询消息
                }
            };
            Thread thread_B = new Thread() {
        
                @Override
                public void run() {
        
                    try {
        
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
        
                        e.printStackTrace();
                    }
                    Message message = handler.obtainMessage();//获取消息
                    message.obj = "Hi A";
                    handler.sendMessage(message);//线程B发送消息给线程A
                }
            };
            thread_A.setName(" Thread_A");
            thread_A.start();
            thread_B.setName("Thread_B");
            thread_B.start();
            /*
            * 搞定，此处创建了两个Thread，thread_A和thread_B两个线程
            * 跟之前的代码没太大区别thread_A创建了Handler，thread_B通过Handler发送了消息。
            * 只不过此处我们只发送一个消息，所以没有使用what来进行标记
            * 值得注意的是：这里多了Looper.prepare() 以及Looper.loop();
            */
        }

##### PS:如果把Looper.prepare()以及Looper.loop()会发生什么事情呢？ #####

答案是：会报以下的错误—> `java.lang.RuntimeException: Can’t create handler inside thread that has not called Looper.prepare()`  
`源码如下：`

//在public Handler(@Nullable Callback callback, boolean async)构造方法中
            mLooper = Looper.myLooper();//获取线程的Looper
            if (mLooper == null) {
        
                throw new RuntimeException(
                    "Can't create handler inside thread " + Thread.currentThread()
                            + " that has not called Looper.prepare()");
            }

##### 因此报错原因是 我们的Handler没有Looper对象。 (因为Looper.prepare方法是生成一个Looper对象，Looper.loop()方法是不断轮询和分发消息) #####

##### `那么在上面主线程中为什么不需要Looper.prepare()和Looper.loop()呢？` #####

##### 其实是因为在ActivityThread.main方法(App初始化)中做了处理。源码如下： #####

Looper.prepareMainLooper(); //获取了主线程的Looper
            ActivityThread thread = new ActivityThread();
            thread.attach(false);
            if (sMainThreadHandler == null) {
        
                sMainThreadHandler = thread.getHandler();
            }
            if (false) {
        
                Looper.myLooper().setMessageLogging(new
                        LogPrinter(Log.DEBUG, "ActivityThread"));
            }  
            Looper.loop(); //不断轮询消息
    /*
     真相只有一个，是的在创建主线程的时候Android已经帮我们调用了Looper.prepareMainLooper()
     和Looper.loop()方法，所以我们在主线程能直接创建Handler使用。
    */

##### 总结：子线程创建Handler实例前要先调用Looper.prepare()，创建完Handler实例后要调用Looper.loop()去轮询和分发消息。 而主线程则不需要，因为系统以及帮我们提前做了处理了。 #####

#### 重要类 Handler，Looper，MessageQueue，Message间的联系 ####

> ##### Handler:负责消息的发送和处理; #####
> 
> ##### Message:消息对象，类似于链表的一个结点; #####
> 
> ##### MessageQueue:消息队列，用于存放消息对象的数据结构; #####
> 
> ##### Looper:消息队列的处理者（用于轮询消息队列的消息对象); #####

##### `Handler发送消息时调用MessageQueue的enqueueMessage插入一条信息到MessageQueue,Looper不断轮询调用MeaasgaQueue的next方法 如果发现message就调用handler的dispatchMessage，dispatchMessage被成功调用，接着调用handlerMessage()。` #####

#### 一个线程可以有几个Handler,几个Looper,几个MessageQueue对象? ####

分析源码：

##### 先从Looper.parpare()开始： #####

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));
        }
        /**
         * 值得注意的是 
         static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
          Looper是用ThreadLocal来存储和获取的，这样确保了一个线程只有一个Looper
          关于ThreadLocal不清楚可以自行查资料
        */

##### 再看看Looper.loop()中做了什么事情： #####

public static void loop() {
        
            final Looper me = myLooper();//获取当前线程的Looper对象
            if (me == null) {
        
               //Looper为null将报错，意思是提示先要获取Looper对象
                throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
            }
            final MessageQueue queue = me.mQueue;//在Looper中，final MessageQueue mQueue; <-- final修饰，说明一个Looper对应一个MessageQueue
            /*
             * 只看重点-->中间省略一大坨代码
            */
            for(;;){
        
                Message msg = queue.next(); // 获取消息，无消息时会阻塞进入等待状态，但可以操作UI，有消息则立马获得消息进行下面操作
                if (msg == null) {
        
                    // No message indicates that the message queue is quitting. <--注释原文
                    //--没有消息指示消息队列正在退出-- 主线程的话 说明程序退出了
                    return;
                }
                /*
                 *中间省略一大坨代码 
                */
                msg.target.dispatchMessage(msg); //分发消息  --target是我们的handler对象,后面会提到-- 
            }
        }

#### 到这里我们基本可以分析出 一个线程中对应只有一个MessageQueue。 ####

##### 再来看看Handler的sendMessage(Message msg)做了什么事情: #####

/*
     * sendMessage内部其实调用的是sendMessageAtTime，最终调用enqueueMessage进行消息的发送
    */    
    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);
        }

##### 因此再来看看Handler的enqueueMessage做了什么事情： #####

/*
     * 分析可知在Handler的enqueueMessage方法中，把handler对象赋值给Message的target
     * 最后调用MessageQueue中的enqueueMessage来发送消息
    */
    private boolean enqueueMessage(@NonNull MessageQueue queue, @NonNull Message msg,
                long uptimeMillis) {
        
            msg.target = this;  //这里的target就是我们的handler对象了(this)，呼应上述的loop()方法
            msg.workSourceUid = ThreadLocalWorkSource.getUid();
            if (mAsynchronous) {
        
                msg.setAsynchronous(true);
            }
            return queue.enqueueMessage(msg, uptimeMillis); //进入MessageQueue的enqueueMessage方法
        }

##### 分析到这里其实可以推断一个线程中可以有多个Handler对象 #####

##### 进入MessageQueue的enqueueMessage方法看下： #####

/*
         * 主要操作为把要分发的消息插入到合适的位置（根据要发送的时间大小来判断）
        */
        boolean enqueueMessage(Message msg, long when) {
        
               /*
                *此处省略了一大坨源码
               */
                Message p = mMessages; //获取消息队列存放的第一个消息(消息头节点)
                boolean needWake;
                if (p == null || when == 0 || when < p.when) {
        
                    //此分支说明消息队列中没有消息，此msg为第一个消息 
                    // 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;
                    //将消息插入到消息队列尾部（即Message链表的尾部）
                    for (;;) {
        
                        prev = p; 
                        p = p.next;
                        if (p == null || when < p.when) {
        
                            //退出条件是 当找到了 第一个比msg发送时间要晚的，或者到了消息队列尾
                            break;
                        }
                        if (needWake && p.isAsynchronous()) {
        
                            needWake = false; 
                        }
                    }
                    msg.next = p; // invariant: p == prev.next 
                    prev.next = msg;  //最后一个消息置为msg（或者找到了第一个比msg要晚发送的消息，则把msg插入在它前面）
                }
                // We can assume mPtr != 0 because mQuitting is false.
                if (needWake) {
        
                    nativeWake(mPtr); //唤醒消息队列
                }
            }
            return true;
        }

#### 因此到现在可以总结出，一个线程中只有一个Looper，一个MessageQueue，但可以有多个Handler ####

##### 最后我们再来看一下分发消息时dispatchMessage是干了什么事情： #####

/*
     *  在Looper.loop()中 msg.target.dispatchMessage(msg) 开始执行该方法; 
     * target就是我们的Handler对象了（上述分析），因此进入Handler的dispatchMessgae查看源码
    */
    public void dispatchMessage(@NonNull Message msg) {
        
            if (msg.callback != null) {
        
                //mCallback 其实是通过handler.post(Runnable callback)传进来的callback对象
                handleCallback(msg);  //这是执行了对应callback对象的run方法
            } else {
        
                if (mCallback != null) {
        
                  //mCallback(Handler.Callback，需要重写handleMessage方法)
                  //可以通过Handler的构造方法传进来
                    if (mCallback.handleMessage(msg)) {
        
                        return;
                    }
                }
                handleMessage(msg);  //调用Handler对象重写的HandleMessage方法处理消息
            }
        }

##### `最后再来总结一下handler机制的工作流程：Handler发送消息时调用MessageQueue的enqueueMessage插入一条信息到MessageQueue,Looper不断轮询调用MeaasgaQueue的next方法 如果发现message就调用handler的dispatchMessage，dispatchMessage被成功调用，接着调用handlerMessage()。` #####

#### Handler机制注意事项： ####

#### 一. Handler使用的注意事项之内存泄漏： ####

##### `原因：` #####

##### 1.Java中非静态内部类和匿名内部类都会隐式持有当前类的外部引用 #####

##### 2.我们在Activity中使用非静态内部类初始化了一个Handler,此Handler就会持有当前Activity的引用 #####

##### 3.我们想要一个对象被回收，那么前提它不被任何其它对象持有引用，所以当我们Activity页面关闭之后,存在引用关系：”未被处理 / 正处理的消息 -> Handler实例 -> 外部类（Activity）”,如果在Handler消息队列 还有未处理的消息 / 正在处理消息时 导致Activity不会被回收，从而造成内存泄漏 #####

##### `解决方案：` #####

###### 1.将Handler的子类设置成 静态内部类,使用WeakReference弱引用持有Activity实例 ######

private Handler mHandler = new BetterHandler(this);
    static class BetterHandler extends Handler {
        
        private WeakReference<Activity> mActivity;
        BetterHandler(Activity activity) {
        
            mActivity = new WeakReference<>(activity);
        }
        @Override
        public void handleMessage(Message msg) {
        
            super.handleMessage(msg);
            Activity activity = mActivity.get();
            if (activity != null) {
        
                //TODO:
            }
        }
    }

###### 2.当外部类结束生命周期时，清空Handler内消息队列 ######

@Override
    protected void onDestroy() {
        
        handler.removeCallbacksAndMessages(null);//传入null就好
        super.onDestroy();
    }

#### 二.MessageQueue是什么数据结构？ ####

##### `MessageQueue内部存储结构并不是真正的队列，而是采用单链表的数据结构来存储消息列表。这点和传统的队列有点不一样，主要区别在于Android的这个队列中的消息是按照时间先后顺序来存储的，时间较早的消息，越靠近队头。 当然，我们也可以理解成，它是先进先出的，只是这里的先依据的不是谁先入队，而是消息待发送的时间` #####

#### 三.Looper.quit/quitSafely的区别 ####

##### 我们调用`Looper的quit方法`时，实际上执行了`MessageQueue中的removeAllMessagesLocked方法`，该方法的作用是把MessageQueue消息池中所有的消息全部清空， 无论是延迟消息`（延迟消息是指通过 sendMessageDelayed或通过postDelayed等方法发送的需要延迟执行的消息）`还是非延迟消息。当我们`调用Looper的quitSafely方法`时，实际上执行了`MessageQueue中的removeAllFutureMessagesLocked 方法`，通过名字就可以看出，该方法只会`清空MessageQueue消息池中所有的延迟消息，并将消息池中所有的非延迟消息派发出去让Handler去处理`，quitSafely相比于quit方法安全之处在于清空消息之前会派发所有的非延迟消息。 #####

##### 源码： #####

void quit(boolean safe) {
        
            synchronized (this) {
        
                if (mQuitting) {
        
                    return;
                }
                mQuitting = true;
                //核心调用
                if (safe) {
        
                    removeAllFutureMessagesLocked(); 
                } else {
        
                    removeAllMessagesLocked();
                }
                // We can assume mPtr != 0 because mQuitting was previously false.
                nativeWake(mPtr);
            }
        }

#### 四.总结通过Handler是如何进行线程通信的 ####

##### `当在A线程中创建handler的时候，同时创建了MessageQueue与Looper，Looper在A线程中调用loop进入一个无限的for循环从MessageQueue中取消息，当B线程调用handler发送一个message的时候，会通过 msg.target.dispatchMessage(msg);将message插入到handler对应的MessageQueue中，Looper发现有message 插入到MessageQueue中，便取出message执行相应的逻辑，因为Looper.loop()是在A线程中启动的，所以则回到了A线程，达到了从B线程切换到A线程进行通信的目的。` #####

#### 五. Message对象创建的方式有哪些 & 区别 ####

##### 1.Message msg = new Message(); 每次需要Message对象的时候都创建一个新的对象，每次都要去堆内存开辟对象存储空间 #####

##### 2.Message msg = Message.obtain(); obtainMessage能避免重复 Message创建对象。它先判断消息池是不是为空，如果非空的话就从消息池表头的Message取走,再把表头指向 next。 如果消息池为空的话说明还没有Message被放进去，那么就new出来一个Message对象。消息池使用 Message 链表结构实现，消息池默认最大值 50。消息在loop中被handler分发消费之后会执行回收的操作，将该消息内部数据清空并添加到消息链表的表头。 #####

##### 3.Message msg = handler.obtainMessage(); 其内部也是调用的obtain() 方法 #####