Handler系列--Message

前言

本系列文章，将分享与Handler相关的知识，包括Handler的结构，运作流程，各个类的作用、之间的关系

内容提要

本篇文章将分析Message的作用，以及主要的方法

重要属性

//Message使用中标记 
static final int FLAG_IN_USE = 1 << 0;
//Message异步标记
static final int FLAG_ASYNCHRONOUS = 1 << 1;
//要在copyFrom方法中清除的标志
static final int FLAGS_TO_CLEAR_ON_COPY_FROM = FLAG_IN_USE;
//Message标记
int flags;

//上一个空闲Message节点
Message next;
//空闲Message链表末尾节点
private static Message sPool;
//空闲Message池数量
private static int sPoolSize = 0;
//空闲Message池最大数量
private static final int MAX_POOL_SIZE = 50;

//Message持有的Handler
Handler target;

重要方法

public static Message obtain()

获取一个可用的Message

1.如果sPool不为空，取sPool，将该Message的next节点置为null，sPoolSize--（表示可用的空闲消息池数量-1）；将sPool指向空闲消息池的下一个消息节点
2.如果sPool为空，直接new一个Message
3.其他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();
    }

public void recycle()

void recycleUnchecked()

回收用完的Message

1.判断是否正在使用，正在使用就不回收
2.回收，如果空闲消息池数量小于最大值，将当前Message加入到空闲消息池链表，空闲消息池数量+1

    public void recycle() {
        if (isInUse()) {         
            return;
        }
        recycleUnchecked();
    }
 
    void recycleUnchecked() { 
        flags = FLAG_IN_USE;
        synchronized (sPoolSync) {
            if (sPoolSize < MAX_POOL_SIZE) {
                next = sPool;
                sPool = this;
                sPoolSize++;
            }
        }
    }

捋一下Message创建回收的思路。创建时优先重用空闲池里面的Message，回收时将空闲Message加入空闲池。下面假设这么一种场景，创建5个Message，然后依次回收，我们看一下是怎样的流程

message创建回收流程.png

1.第一次创建的过程比较简单，可以看到，由于一开始并没有空闲Message可供重用，所以sPool和sPoolSize都是不变的
2.我们重点看一下回收过程
- 在回收Message1时，sPool == null，所以next = sPool = null，然后sPool = this，也就是Message1已经被加入空闲池，sPoolSize也相应增加了；
- 回收Message2时，next = sPool = Message1，这里就把Message1跟Message2串联起来了，我们就可以从Message2索引到Message1（可以想见，后面的n个Message，都可以通过Message(n).next找到Message(n-1)），sPool = this表示将sPool指向链表的末尾（即Message2）
3.第二次创建，由于空闲池已经有可供使用的Message，会取链表末尾的节点来使用（ Message m = sPool），然后将sPool指向末尾节点的下一个节点（sPool = m.next），最后，将取出的Message与空闲池链表断开联系（m.next = null），sPoolSize-1

boolean isInUse()

Message是否使用中

1.FLAG_IN_USE = 1 << 0，二进制为00000001，只要flags为YYYYYYY1，isInUse()就为true

    boolean isInUse() {
        return ((flags & FLAG_IN_USE) == FLAG_IN_USE);
    }

void markInUse()

设置Message状态为使用中

1.markInUse()之后，flags == 00000001，就是说isInUse()==true

    
    void markInUse() {
        flags |= FLAG_IN_USE;
    }

public void sendToTarget()

用持有的Handler发送消息

    public void sendToTarget() {
        target.sendMessage(this);
    }

本篇内容到此结束，感谢收看~~