EventBus3.0源码学习(2) post

发送事件(post)

当需要发送事件时，调用EventBus.getDefault().post(event)即可，EventBus会将事件发送给所有已经注册了监听该类事件的订阅者。post的实现如下：

 1 public void post(Object event) {
 2     PostingThreadState postingState = currentPostingThreadState.get();
 3     List<Object> eventQueue = postingState.eventQueue;
 4     eventQueue.add(event);
 5 
 6     if (!postingState.isPosting) {
 7         postingState.isMainThread = Looper.getMainLooper() == Looper.myLooper();
 8         postingState.isPosting = true;
 9         if (postingState.canceled) {
10             throw new EventBusException("Internal error. Abort state was not reset");
11         }
12         try {
13             while (!eventQueue.isEmpty()) {
14                 postSingleEvent(eventQueue.remove(0), postingState);
15             }
16         } finally {
17             postingState.isPosting = false;
18             postingState.isMainThread = false;
19         }
20     }
21 }

第2-4行，currentPostingThreadState是ThreadLocal<PostingThreadState>范型类的实例，记录了每个线程的发送事件的状态，event被放入postingState.eventQueue中。

第6-20行，如果postingState.isPosting为false，表明线程没有在发送消息，则调用postSingleEvent函数发送postingState.eventQueue队首的消息，直至队列为空。finally块用于保证无论postSingleEvent是否发生异常，当前线程的postingState保存的状态都能被正确复位。 postSingleEvent的实现如下：

 1 private void postSingleEvent(Object event, PostingThreadState postingState) throws Error {
 2     Class<?> eventClass = event.getClass();
 3     boolean subscriptionFound = false;
 4     if (eventInheritance) {
 5         List<Class<?>> eventTypes = lookupAllEventTypes(eventClass);
 6         int countTypes = eventTypes.size();
 7         for (int h = 0; h < countTypes; h++) {
 8             Class<?> clazz = eventTypes.get(h);
 9             subscriptionFound |= postSingleEventForEventType(event, postingState, clazz);
10         }
11     } else {
12         subscriptionFound = postSingleEventForEventType(event, postingState, eventClass);
13     }
14     if (!subscriptionFound) {
15         if (logNoSubscriberMessages) {
16             Log.d(TAG, "No subscribers registered for event " + eventClass);
17         }
18         if (sendNoSubscriberEvent && eventClass != NoSubscriberEvent.class &&
19                 eventClass != SubscriberExceptionEvent.class) {
20             post(new NoSubscriberEvent(this, event));
21         }
22     }
23 }

第4-10行，若eventInheritance为true，则调用lookAllEventTypes将所有类和接口T满足<T super eventClass>找到。根据面向对象的里氏替换原则：一个对象可以被当作其父类对象、其实现的任意接口对象。因此，考虑类继承的情况下，当发送一个事件时，监听其超类体系的任意父类事件和任意接口事件的订阅者，也应该收到相应消息。lookAllEventTypes的实现如下：

 1 private static List<Class<?>> lookupAllEventTypes(Class<?> eventClass) {
 2     synchronized (eventTypesCache) {
 3         List<Class<?>> eventTypes = eventTypesCache.get(eventClass);
 4         if (eventTypes == null) {
 5             eventTypes = new ArrayList<>();
 6             Class<?> clazz = eventClass;
 7             while (clazz != null) {
 8                 eventTypes.add(clazz);
 9                 addInterfaces(eventTypes, clazz.getInterfaces());
10                 clazz = clazz.getSuperclass();
11             }
12             eventTypesCache.put(eventClass, eventTypes);
13         }
14         return eventTypes;
15     }
16 }
17 
18 static void addInterfaces(List<Class<?>> eventTypes, Class<?>[] interfaces) {
19     for (Class<?> interfaceClass : interfaces) {
20         if (!eventTypes.contains(interfaceClass)) {
21             eventTypes.add(interfaceClass);
22             addInterfaces(eventTypes, interfaceClass.getInterfaces());
23         }
24     }
25 }

第7-11行，递归查找eventClass超类体系的所有类及其实现的接口。当clazz为Object、interface、void 或基本数据类型(byte, short, int, long, float, double, boolean, char)时，clazz.getSuperClass()返回null。

第20行，由于父类和子类可能同时声明实现同一接口，因此需要判断interfaceClass是否已经被添加过了。

eventTypeCache存储了<eventClass, eventTypes>的映射关系，这是一种优化手段，避免每次发送事件时都去查找eventClass的超类体系。

postSingleEvent最终调用postSingleEventForEventType发送事件，postSingleEventForEventType的实现如下：

 1 private boolean postSingleEventForEventType(Object event, PostingThreadState postingState, Class<?> eventClass) {
 2     CopyOnWriteArrayList<Subscription> subscriptions;
 3     synchronized (this) {
 4         subscriptions = subscriptionsByEventType.get(eventClass);
 5     }
 6     if (subscriptions != null && !subscriptions.isEmpty()) {
 7         for (Subscription subscription : subscriptions) {
 8             postingState.event = event;
 9             postingState.subscription = subscription;
10             boolean aborted = false;
11             try {
12                 postToSubscription(subscription, event, postingState.isMainThread);
13                 aborted = postingState.canceled;
14             } finally {
15                 postingState.event = null;
16                 postingState.subscription = null;
17                 postingState.canceled = false;
18             }
19             if (aborted) {
20                 break;
21             }
22         }
23         return true;
24     }
25     return false;
26 }

第3-5行，从subscriptionsByEventType中查找订阅了eventClass事件的subscriptions。该操作是在synchronized块中，因为register和unregister操作会从其他线程修改subscriptionsByEventType。

第6-22行，依次调用postToSubscription函数，将event发送给subscriptions中的每个subscription。postToSubscription调用之后，postingState.canceled被赋值给aborted，而在finally块中，postingState.canceled又被复位。显然，若postToSubscription调用过程中postingState.canceled若被置位，则subscriptions中后续的所有subscription将无法接收到本次发送的事件。由于subscriptions中的subscription是以subscrberMethod.priority排序的，因此，高优先级的订阅者可以阻止低优先级的订阅者接收到本次事件。由于postingState是线程本地变量，因此高优先级的订阅者如果想这么做，则必须以POSTING模式接收事件，调用cancelEventDelivery(event)即可。

postToSubscription是真正分发事件的函数，其实现如下：

 1 private void postToSubscription(Subscription subscription, Object event, boolean isMainThread) {
 2     switch (subscription.subscriberMethod.threadMode) {
 3         case POSTING:
 4             invokeSubscriber(subscription, event);
 5             break;
 6         case MAIN:
 7             if (isMainThread) {
 8                 invokeSubscriber(subscription, event);
 9             } else {
10                 mainThreadPoster.enqueue(subscription, event);
11             }
12             break;
13         case BACKGROUND:
14             if (isMainThread) {
15                 backgroundPoster.enqueue(subscription, event);
16             } else {
17                 invokeSubscriber(subscription, event);
18             }
19             break;
20         case ASYNC:
21             asyncPoster.enqueue(subscription, event);
22             break;
23         default:
24             throw new IllegalStateException("Unknown thread mode: " + subscription.subscriberMethod.threadMode);
25     }
26 }
27 
28 void invokeSubscriber(Subscription subscription, Object event) {
29     try {
30         subscription.subscriberMethod.method.invoke(subscription.subscriber, event);
31     } catch (InvocationTargetException e) {
32         handleSubscriberException(subscription, event, e.getCause());
33     } catch (IllegalAccessException e) {
34         throw new IllegalStateException("Unexpected exception", e);
35     }
36 }

postToSubscription最终调用invokeSubscriber，以event为参数调用subscriber对象处理event事件的函数(即subscriberMethod)。显然如果subscriberMethod处理event时发生异常，是可能会导致整个程序崩溃的。

第2-25行，switch块实现了EventBus中threadMode的定义：

POSTING：该模式不需要线程切换，为默认模式。subscriberMethod直接在post线程执行。
MAIN：若当前线程是主线程，则与POSTING一样；否则，由mainThreadPoster进行处理。当我们需要更新UI时，会采用这种模式。
BACKGROUND：若当前线程不是主线程，则与POSTING一样；否则，由backgroundPoster进行处理。backgroundPoster中的任务是串行执行的。
ASYNC：该模式总是需要进行线程切换，由asyncPoster进行处理。