EventBus要点解析

使用流程

register(object)eventBus.post(event)

举个简单例子

基类Activity

public class CommonActivity extends AppCompatActivity {    protected EMEventBus eventBus;    @Override    protected void onCreate(Bundle savedInstanceState) {        super.onCreate(savedInstanceState);        eventBus = EMEventBus.getDefault();        eventBus.register(this);    }    @Override    protected void onDestroy() {        super.onDestroy();        eventBus.unregister(this);    }    //EventBus至少有一个onEvent方法    public void onEvent(String defaultEvent) {    }}

登录页面只订阅一个LoginEvent

public class LoginActivity extends CommonActivity {    public void onEventMainThread(LoginEvent event) {    }}

当在另一个页面 eventBus.post(new LoginEvent()) 的时候发生了什么
- #register

当LoginActivity页面register的时候

subscriberMethodFinder.findSubscriberMethods(subscriber.getClass());

先找出所有LoginActivity中订阅的Event

 {    LoginActivity.onEventMainThread(me.ele.crowdsource.event.LoginEvent)    CommonActivity.onEvent(java.lang.String) }

然后for循环生成EventBus中第一重要的映射

private final Map<Class<?>, CopyOnWriteArrayList<Subscription>> subscriptionsByEventType;

为什么说这个映射重要，因为他对应着一个Event->List订阅这个Event的对象，有了这个映射，当你要post(event)的时候，就可以轻松找到所有响应的订阅者。注意，这个list的类型是CopyOnWriteArrayList

   CopyOnWriteArrayList是ArrayList 的一个线程安全的变体，其中所有可变操作（add、set等等）都是通过对底层数组进行一次新的复制来实现的。 CopyOnWriteArrayList适合使用在读操作远远大于写操作的场景里，比如缓存。发生修改时候做copy，新老版本分离，保证读的高性能，适用于以读为主的情况。

接着生成了EventBus中第二重要的映射
private final Map

 List<Class<?>> subscribedEvents = typesBySubscriber.get(subscriber);        if (subscribedEvents == null) {            subscribedEvents = new ArrayList<Class<?>>();            typesBySubscriber.put(subscriber, subscribedEvents);        }  subscribedEvents.add(eventType);

生成了subscriptionsByEventType和typesBySubscriber 这俩个map，register的任务就结束了。

• #post

试想如果你来实现EventBus，当Post一个event的时候，怎么搞？很简单是根据subscriptionsByEventType找到所有订阅的方法，然后执行。再看EventBus如何实现的，哈哈，也就是这个思路。只是多了个查找Event所有的父类和实现的接口过程.

 /** Looks up all Class objects including super classes and interfaces. Should also work for interfaces. */    private List<Class<?>> lookupAllEventTypes(Class<?> eventClass) {        synchronized (eventTypesCache) {            List<Class<?>> eventTypes = eventTypesCache.get(eventClass);            if (eventTypes == null) {                eventTypes = new ArrayList<Class<?>>();                Class<?> clazz = eventClass;                while (clazz != null) {                    eventTypes.add(clazz);                    addInterfaces(eventTypes, clazz.getInterfaces());                    clazz = clazz.getSuperclass();                }                eventTypesCache.put(eventClass, eventTypes);            }            return eventTypes;        }    }

寻找订阅的核心实现在这里

 private boolean postSingleEventForEventType(Object event, PostingThreadState postingState, Class<?> eventClass) {        CopyOnWriteArrayList<Subscription> subscriptions;        synchronized (this) {            subscriptions = subscriptionsByEventType.get(eventClass);        }        if (subscriptions != null && !subscriptions.isEmpty()) {            for (Subscription subscription : subscriptions) {              ···             postToSubscription(subscription, event, postingState.isMainThread);               ···        }        return false;    }

当真正去响应各个订阅方法的时候，出现了EventBus的核心实现-用

  private final HandlerPoster mainThreadPoster;  private final BackgroundPoster backgroundPoster;  private final AsyncPoster asyncPoster;

三个队列来处理所有的方法。关于这里队列的介绍之前总结过一次
有兴趣的可以看这里，类似的实现handle中也有，自己的项目中也可以用。

postToSubscription 函数中会判断订阅者的 ThreadMode，从而决定在什么 Mode 下执行事件响应函数。ThreadMode 共有四类：

• PostThread：默认的 ThreadMode，表示在执行 Post 操作的线程直接调用订阅者的事件响应方法，不论该线程是否为主线程（UI 线程）。当该线程为主线程时，响应方法中不能有耗时操作，否则有卡主线程的风险。适用场景：对于是否在主线程执行无要求，但若 Post 线程为主线程，不能耗时的操作；

• MainThread：在主线程中执行响应方法。如果发布线程就是主线程，则直接调用订阅者的事件响应方法，否则通过主线程的 Handler 发送消息在主线程中处理——调用订阅者的事件响应函数。显然，MainThread类的方法也不能有耗时操作，以避免卡主线程。适用场景：必须在主线程执行的操作；

• BackgroundThread：在后台线程中执行响应方法。如果发布线程不是主线程，则直接调用订阅者的事件响应函数，否则启动唯一的后台线程去处理。由于后台线程是唯一的，当事件超过一个的时候，它们会被放在队列中依次执行，因此该类响应方法虽然没有PostThread类和MainThread类方法对性能敏感，但最好不要有重度耗时的操作或太频繁的轻度耗时操作，以造成其他操作等待。适用场景：操作轻微耗时且不会过于频繁，即一般的耗时操作都可以放在这里；

• Async：不论发布线程是否为主线程，都使用一个空闲线程来处理。和BackgroundThread不同的是，Async类的所有线程是相互独立的，因此不会出现卡线程的问题。适用场景：长耗时操作，例如网络访问。

post方法中关于线程的处理也耐人寻味，尤其是这个currentPostingThreadState

    private final ThreadLocal<PostingThreadState> currentPostingThreadState = new ThreadLocal<PostingThreadState>() {        @Override        protected PostingThreadState initialValue() {            return new PostingThreadState();        }    };

每次post可能在不同的线程，这个时候使用ThreadLocal使得各线程能够保持各自独立的一个对象，从源码可以看出

    public T get() {         Thread t = Thread.currentThread();         ThreadLocalMap map = getMap(t);         if (map != null) {             ThreadLocalMap.Entry e = map.getEntry(this);             if (e != null)                 return (T)e.value;         }         return setInitialValue();     }

这说明ThreadLocal确实只有一个变量，但是它内部包含一个map，针对每个thread保留一个entry，如果对应的thread不存在则会调用initialValue。
再回到EventBus

       final static class PostingThreadState {            final List<Object> eventQueue = new ArrayList<Object>();            boolean isPosting;            boolean isMainThread;            Subscription subscription;            Object event;            boolean canceled;        }

每个线程维护一个eventQueue,每次post就循环的去发送

    PostingThreadState postingState = currentPostingThreadState.get();    List<Object> eventQueue = postingState.eventQueue;    eventQueue.add(event);    while (!eventQueue.isEmpty()) {         postSingleEvent(eventQueue.remove(0), postingState);       }

• #unregister

unregister思路很简单，就是清除typesBySubscriber里面这个Activity的记录和subscriptionsByEventType中对应的记录，但是这里有个删除list中元素的技巧很有趣。因为之前兆轩刚在上面踩过坑,看EventBus如何删除subscriptionsByEventType中一个event对应的订阅list中某个记录。

    private void unubscribeByEventType(Object subscriber, Class<?> eventType) {        List<Subscription> subscriptions = subscriptionsByEventType.get(eventType);        if (subscriptions != null) {            int size = subscriptions.size();            for (int i = 0; i < size; i++) {                Subscription subscription = subscriptions.get(i);                if (subscription.subscriber == subscriber) {                    subscription.active = false;                    subscriptions.remove(i);                    i--;                    size--;                }            }        }    }

重点就是i–和size–,当命中的时候通过–让游标回退一位，size也减一，这样就可以让剩下的元素也正常循环完成。

到此为止，EventBus我认为比较有意思的地方就都列出来了，还是学到了蛮多的东西。