综合技术

Android源码handler机制之Message

微信扫一扫,分享到朋友圈

Android源码handler机制之Message
0

1 源码注释

// 定义一个包含描述和任务数据对象的message,且message能被handler发送,这个对象包含两个extra int域和一个extra object域,它们能让你在很多情况下不必做分配工作。
// 虽然Message的构造器是public的,但是最好是通过Message.obtain()方法获取Handler.obtainMessage()来获取,这样能复用Message对象,减轻创建Message对象所造成的消耗。
public final class Message implements Parcelable {
    /**
     * 用户自定义一个code,用例区分这个Message是什么内容。
     * 每个Handler有它自己的名字空间用于what,所以你不必担心和其它Handler的Message.what会冲突
     */
    public int what;

    /**
     * 如果你只想在Messag里放int数据,你可以直接用这个变量来存放
     */
    public int arg1;

    /**
     * 如果你只想在Messag里放int数据,你可以直接用这个变量来存放
     */
    public int arg2;

    /**
     * 要发给接收者的对象,当使用Messager去发Message进行跨进程通信时,如果它包含Parceable,那么这个变量不能为空。 对于其它的数据传输请用setData()
     */
    public Object obj;

    /**
     * 可选的Messager,它可以发送此消息的答复。具体如何使用还需要取决于发送方和接收方,一般是用在跨进程通信上
     */
    public Messenger replyTo;

    /**
     * 可选的域,用来指示发送消息的uid.这个只能对Messager发送的消息有效,否则默认都是-1
     */
    public int sendingUid = -1;

     /*
     * 一个标志:表示这个消息是在使用
     * 这个flag是在message入队时被设置,在被分发时保留设置,最后回收时也保留设置。这个flag只有在一个创建新Message或获取新Message时才能被请空,因为这是程序唯一允许修改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;
    // 放标记 
    int flags;
    // 放时间
    long when;
    // 放消息内容
    Bundle data;
    // 接收消息的handler
    Handler target;
    // runable
    Runnable callback;
    // 单链表里下一个message
    Message next;
    // 对象池用的同步锁对象
    public static final Object sPoolSync = new Object();
    // 对象池,对象池是一个单链表,所以一个Message对象就可以代表对象池
    private static Message sPool;
    // 对象池大小
    private static int sPoolSize = 0;
    // 常量,对象池大小最多为50
    private static final int MAX_POOL_SIZE = 50;
    // 检查回收标志
    private static boolean gCheckRecycle = true;

    /**
     * 获取一个新Message对象,可能是从全局对象池里获取的。
     * 不用我们自己在new一个
     */
    public static Message obtain() {
        // 因为对象池是一个单链表,所以从链表的头部取
        synchronized (sPoolSync) {// 加同步
            if (sPool != null) {
                Message m = sPool;
                sPool = m.next;
                m.next = null;
                m.flags = 0; // 清空flag
                sPoolSize--; // 对象池大小减一
                return m;
            }
        }
        return new Message();
    }

    /**
     * 和obtain()方法一样,只是将传入的message内容复制到新获取的Message中返回
     */
    public static Message obtain(Message orig) {
        Message m = obtain();
        m.what = orig.what;
        m.arg1 = orig.arg1;
        m.arg2 = orig.arg2;
        m.obj = orig.obj;
        m.replyTo = orig.replyTo;
        m.sendingUid = orig.sendingUid;
        if (orig.data != null) {
            m.data = new Bundle(orig.data);
        }
        m.target = orig.target;
        m.callback = orig.callback;

        return m;
    }
    /*
     * 从对象池获取一个新message,并且它的target为传入的handler
     */
    public static Message obtain(Handler h) {
        Message m = obtain();
        m.target = h;

        return m;
    }

    /*
     * 从对象池获取一个新message,并且它的target为传入的handler,它的callback为传入的callback
     */
    public static Message obtain(Handler h, Runnable callback) {
        Message m = obtain();
        m.target = h;
        m.callback = callback;

        return m;
    }

    /*
     * 从对象池获取一个新message,并且它的target为传入的handler,它的what为传入的what
     */
    public static Message obtain(Handler h, int what) {
        Message m = obtain();
        m.target = h;
        m.what = what;

        return m;
    }
        /*
     * 从对象池获取一个新message,并且它的target,what,obj为传入的handler,what,obj
     */
    public static Message obtain(Handler h, int what, Object obj) {
        Message m = obtain();
        m.target = h;
        m.what = what;
        m.obj = obj;

        return m;
    }

    /*
     * 从对象池获取一个新message,并且它的target,what,arg1,arg2为传入的handler,what,arg1,arg2
     */
    public static Message obtain(Handler h, int what, int arg1, int arg2) {
        Message m = obtain();
        m.target = h;
        m.what = what;
        m.arg1 = arg1;
        m.arg2 = arg2;

        return m;
    }
    /*
     * 从对象池获取一个新message,并且它的target,what,arg1,arg2,obj为传入的handler,what,arg1,arg2,obj
     */
    public static Message obtain(Handler h, int what,
            int arg1, int arg2, Object obj) {
        Message m = obtain();
        m.target = h;
        m.what = what;
        m.arg1 = arg1;
        m.arg2 = arg2;
        m.obj = obj;

        return m;
    }

    /** 更新检查回收标记 */
    public static void updateCheckRecycle(int targetSdkVersion) {
        if (targetSdkVersion < Build.VERSION_CODES.LOLLIPOP) {
            // 如果版本小于Android5.0 则检查回收标志为false
            gCheckRecycle = false;
        }
    }

    /**
     * 如果message不在使用中,则回收对象
     */
    public void recycle() {
        if (isInUse()) {
            if (gCheckRecycle) {
                throw new IllegalStateException("This message cannot be recycled because it "
                        + "is still in use.");
            }
            return;
        }
        recycleUnchecked();
    }

    /**
     * 向对象池添加一个对象
     */
    void recycleUnchecked() {
        flags = FLAG_IN_USE;
        what = 0;
        arg1 = 0;
        arg2 = 0;
        obj = null;
        replyTo = null;
        sendingUid = -1;
        when = 0;
        target = null;
        callback = null;
        data = null;

        synchronized (sPoolSync) {
            if (sPoolSize < MAX_POOL_SIZE) {
                next = sPool;
                sPool = this;
                sPoolSize++;
            }
        }
    }

    /**
     * 复制指定Message的内容
     */
    public void copyFrom(Message o) {
        this.flags = o.flags & ~FLAGS_TO_CLEAR_ON_COPY_FROM;
        this.what = o.what;
        this.arg1 = o.arg1;
        this.arg2 = o.arg2;
        this.obj = o.obj;
        this.replyTo = o.replyTo;
        this.sendingUid = o.sendingUid;

        if (o.data != null) {
            this.data = (Bundle) o.data.clone();
        } else {
            this.data = null;
        }
    }

    /**
     * Return the targeted delivery time of this message, in milliseconds.
     * 返回消息被分发的时间,用毫秒表示
     */
    public long getWhen() {
        return when;
    }
    
    public void setTarget(Handler target) {
        this.target = target;
    }
    /**
    * 获取接收Message的Handler
    */
    public Handler getTarget() {
        return target;
    }

    /**
     * 回调对象
     */
    public Runnable getCallback() {
        return callback;
    }

    /** 设置消失里的回调对象 */
    public Message setCallback(Runnable r) {
        callback = r;
        return this;
    }

    /**
     * 获取Bundle
     */
    public Bundle getData() {
        if (data == null) {
            data = new Bundle();
        }

        return data;
    }

    public Bundle peekData() {
        return data;
    }

    /**
     * 设置data
     */
    public void setData(Bundle data) {
        this.data = data;
    }

    /**
     * 设置what
     */
    public Message setWhat(int what) {
        this.what = what;
        return this;
    }

    /**
     * 将消息发给接受者Handler
     */
    public void sendToTarget() {
        target.sendMessage(this);
    }

    /**
     * 消息是否是异步的
     */
    public boolean isAsynchronous() {
        return (flags & FLAG_ASYNCHRONOUS) != 0;
    }

    /**
     * 设置这个消息是否是异步的
     */
    public void setAsynchronous(boolean async) {
        if (async) {
            flags |= FLAG_ASYNCHRONOUS;
        } else {
            flags &= ~FLAG_ASYNCHRONOUS;
        }
    }
    /**
    * 消息是否正在使用
    */
     boolean isInUse() {
        return ((flags & FLAG_IN_USE) == FLAG_IN_USE);
    }
    /**
    * 标记消息正在使用
    */
     void markInUse() {
        flags |= FLAG_IN_USE;
    }

    /** Constructor (but the preferred way to get a Message is to call {@link #obtain() Message.obtain()}).
    */
    public Message() {
    }

    @Override
    public String toString() {
        return toString(SystemClock.uptimeMillis());
    }

    String toString(long now) {
        StringBuilder b = new StringBuilder();
        b.append("{ when=");
        TimeUtils.formatDuration(when - now, b);

        if (target != null) {
            if (callback != null) {
                b.append(" callback=");
                b.append(callback.getClass().getName());
            } else {
                b.append(" what=");
                b.append(what);
            }

            if (arg1 != 0) {
                b.append(" arg1=");
                b.append(arg1);
            }

            if (arg2 != 0) {
                b.append(" arg2=");
                b.append(arg2);
            }

            if (obj != null) {
                b.append(" obj=");
                b.append(obj);
            }

            b.append(" target=");
            b.append(target.getClass().getName());
        } else {
            b.append(" barrier=");
            b.append(arg1);
        }

        b.append(" }");
        return b.toString();
    }

    void writeToProto(ProtoOutputStream proto, long fieldId) {
        final long messageToken = proto.start(fieldId);
        proto.write(MessageProto.WHEN, when);

        if (target != null) {
            if (callback != null) {
                proto.write(MessageProto.CALLBACK, callback.getClass().getName());
            } else {
                proto.write(MessageProto.WHAT, what);
            }

            if (arg1 != 0) {
                proto.write(MessageProto.ARG1, arg1);
            }

            if (arg2 != 0) {
                proto.write(MessageProto.ARG2, arg2);
            }

            if (obj != null) {
                proto.write(MessageProto.OBJ, obj.toString());
            }

            proto.write(MessageProto.TARGET, target.getClass().getName());
        } else {
            proto.write(MessageProto.BARRIER, arg1);
        }

        proto.end(messageToken);
    }

    public static final Parcelable.Creator<Message> CREATOR
            = new Parcelable.Creator<Message>() {
        public Message createFromParcel(Parcel source) {
            Message msg = Message.obtain();
            msg.readFromParcel(source);
            return msg;
        }

        public Message[] newArray(int size) {
            return new Message[size];
        }
    };

    public int describeContents() {
        return 0;
    }

    public void writeToParcel(Parcel dest, int flags) {
        if (callback != null) {
            throw new RuntimeException(
                "Can't marshal callbacks across processes.");
        }
        dest.writeInt(what);
        dest.writeInt(arg1);
        dest.writeInt(arg2);
        if (obj != null) {
            try {
                Parcelable p = (Parcelable)obj;
                dest.writeInt(1);
                dest.writeParcelable(p, flags);
            } catch (ClassCastException e) {
                throw new RuntimeException(
                    "Can't marshal non-Parcelable objects across processes.");
            }
        } else {
            dest.writeInt(0);
        }
        dest.writeLong(when);
        dest.writeBundle(data);
        Messenger.writeMessengerOrNullToParcel(replyTo, dest);
        dest.writeInt(sendingUid);
    }

    private void readFromParcel(Parcel source) {
        what = source.readInt();
        arg1 = source.readInt();
        arg2 = source.readInt();
        if (source.readInt() != 0) {
            obj = source.readParcelable(getClass().getClassLoader());
        }
        when = source.readLong();
        data = source.readBundle();
        replyTo = Messenger.readMessengerOrNullFromParcel(source);
        sendingUid = source.readInt();
    }
}

2 设计点

2.1 Message对象池的设计

因为每个Hander可能会处理大量Message,而每次发送Message时都要构造一个Message对象肯定是不佳的做法,所以可以定义一个全局的Message对象池,当Message被消费了之后,可以把它会收到对象池,然后获取新Message填消息内容时,Message对象可以从对象池中取出。

好处:

  • 减少不必要的新建对象造成的资源消耗

2.2 Message对象池的实现

对象池为什么不用map?

实现对象池有多种方式:

  • 容易想到的就是用Map结构
  • 用链表
  • 用数组

Message对象池的结构并不是map那种结构,而是一个单链表,应该是因为单链表很容易在链表头插入和取出元素,而Map对象太重了,而且管理元素还需要key,我觉得map应该是适合存放不同类型的对象。而Message的业务只需要Message一种类型的对象池,所有采用链表。如果用数组,显而易见,数组来实现元素的插入和取出太麻烦了,而且效率也不好。

所以总结下来:选取对象池的结构:如果用于管理多类型对象,并且一个类型一个元素则优先用map(这个就有点像单例了)。如果用于单种类型多个元素,则优先用链表。

对象池操作的线程安全?

可以从源码中看到每次对象池的操作的线程安全实现是在单独一个object上加锁。

为什么要这样?

  • 给Message.class加锁:对象池是一个静态变量,操作方法也是静态方法,没必要在类上加锁

阅读原文...


微信扫一扫,分享到朋友圈

Android源码handler机制之Message
0

简书

在python异步协程中处理流程分析(二)

上一篇

无货源店群规则不断,还能走多远?精细化运营操作,迎合规则稳定发展

下一篇

评论已经被关闭。

插入图片

热门分类

往期推荐

Android源码handler机制之Message

长按储存图像,分享给朋友