簡介
我們知道，Android應用主要是由4大組件構成。當我們進行組件間通訊時，由于位于不同的組件，通信方式相對麻煩。基于此，EventBus便油然而生。通過EventBus，我們可以很輕松的進行組件間通信。
使用方法
EventBus in 3 steps
Define events:
public static class MessageEvent { /* Additional fields if needed */ }
Prepare subscribers: Declare and annotate your subscribing method, optionally specify a thread mode:
@Subscribe(threadMode = ThreadMode.MAIN)
public void onMessageEvent(MessageEvent event) {/* Do something */};
Register and unregister your subscriber. For example on Android, activities and fragments should usually register according to their life cycle:
@Override
public void onStart() {
super.onStart();
EventBus.getDefault().register(this);
}
@Override
public void onStop() {
super.onStop();
EventBus.getDefault().unregister(this);
}
Post events:
EventBus.getDefault().post(new MessageEvent());
Read the full getting started guide.
源碼解析
EventBus的使用，無外乎主要就是訂閱，事件發送和解除訂閱3大步驟，那么源碼解析我們也從這3個方面進行入手。
(1). 訂閱
使用EventBus時，第一步肯定是先進行注冊，通常使用的就是：
EventBus.getDefault().register(this);
那我們就先來看下：EventBus.getDefault()
public EventBus() {
this(DEFAULT_BUILDER);
}
/** Convenience singleton for apps using a process-wide EventBus instance. */
public static EventBus getDefault() {
if (defaultInstance == null) {
synchronized (EventBus.class) {
if (defaultInstance == null) {
defaultInstance = new EventBus();
}
}
}
return defaultInstance;
}
可以看到，getDefault()其實就是用的雙重鎖校驗來實現一個單例EventBus，但是跟普通的單例模式不同的是，EventBus的默認構造函數確是public的，其實這里的public是有深層含義的，當我們使用getDefault()時獲取的EventBus，只是一條事件總線，如果我們想構造多條事件總線，那么我們就可以直接實例化EventBus即可。
接下來我們來看下EventBus的注冊過程:
/**
* Registers the given subscriber to receive events. Subscribers must call {@link #unregister(Object)} once they
* are no longer interested in receiving events.
* <p/>
* Subscribers have event handling methods that must be annotated by {@link Subscribe}.
* The {@link Subscribe} annotation also allows configuration like {@link
* ThreadMode} and priority.
*/
public void register(Object subscriber) {
Class<?> subscriberClass = subscriber.getClass();
//找到subscriber源文件（及其父類）中注冊的事件方法
List<SubscriberMethod> subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);
synchronized (this) {
for (SubscriberMethod subscriberMethod : subscriberMethods) {
//按事件將所有的subscirber記錄下來，并依據priority進行排序，
// 如果是sticky事件，則從粘性記錄中查找是否前面已經分發了該事件通知，
// 如果是，則立即調用該subscriber的subscriberMethod。
subscribe(subscriber, subscriberMethod);
}
}
}
從register源代碼可以看到，注冊過程主要分為2個步驟:
1.通過findSubscriberMethods()方法，就可以找到對應subscriber中注冊的事件方法;
2.subscribe()過程，記錄subscriber并排序，對注冊者進行粘性事件調用···
那首先，我們先分析下findSubscriberMethods()，其具體的查找過程如下：
List<SubscriberMethod> findSubscriberMethods(Class<?> subscriberClass) {
List<SubscriberMethod> subscriberMethods = METHOD_CACHE.get(subscriberClass);
if (subscriberMethods != null) {
return subscriberMethods;
}
//是否忽略從注解器生成的MyEventBusIndex類獲取事件方法，默認為false
if (ignoreGeneratedIndex) {
subscriberMethods = findUsingReflection(subscriberClass);
} else {
subscriberMethods = findUsingInfo(subscriberClass);
}
if (subscriberMethods.isEmpty()) {
throw new EventBusException("Subscriber " + subscriberClass
+ " and its super classes have no public methods with the @Subscribe annotation");
} else {
//將subscriberClass類（連同父類）對應的@Subscribe方法進行緩存
METHOD_CACHE.put(subscriberClass, subscriberMethods);
return subscriberMethods;
}
}
METHOD_CACHE是一個全局靜態的ConcurrentHashMap，
private static final Map<Class<?>, List<SubscriberMethod>> METHOD_CACHE = new ConcurrentHashMap<>();
從METHOD_CACHE中我們可以得知，它會緩存所有事件總線的所有subscriber對應的所有事件方法。
EventBus3.0相對于之前的版本，性能上有了很大的提升，提升的主要原因就在于事件信息的獲取來源：舊版本事件信息都是通過采用反射來獲取，而新版本默認是采用編譯器注解方式（如果還不清楚注解處理器的內容，可以參考下我之前的簡文：注解處理器（Annotation Processor）簡析），在編譯的時候通過@Subscribe注解獲取事件信息，從而在效率上得到很大的提升。
所以，register中，findUsingReflection(subscriberClass)采用的便是運行時反射獲取，findUsingInfo(subscriberClass)采用的就是從apt自動生成的MyEventBusIndex類中獲取事件信息。
這里，我們就只對findUsingInfo()進行分析：
/**
*
* @param subscriberClass
* @return 獲取subscriberClass及其父類的@Subscribe方法
*/
private List<SubscriberMethod> findUsingInfo(Class<?> subscriberClass) {
FindState findState = prepareFindState();
findState.initForSubscriber(subscriberClass);
while (findState.clazz != null) {
//從apt自動生成的MyEventBusIndex類中獲取SubscriberInfo
findState.subscriberInfo = getSubscriberInfo(findState);
if (findState.subscriberInfo != null) {
SubscriberMethod[] array = findState.subscriberInfo.getSubscriberMethods();
for (SubscriberMethod subscriberMethod : array) {
if (findState.checkAdd(subscriberMethod.method, subscriberMethod.eventType)) {
findState.subscriberMethods.add(subscriberMethod);
}
}
} else {
findUsingReflectionInSingleClass(findState);
}
findState.moveToSuperclass();
}
return getMethodsAndRelease(findState);
}
這里FindState的設計采用享元模式，避免FindState的頻繁創建，具體詳情可以查看附錄介紹。
void initForSubscriber(Class<?> subscriberClass) {
this.subscriberClass = clazz = subscriberClass;
skipSuperClasses = false;
subscriberInfo = null;
}
findState.initForSubscriber(subscriberClass)中，我們可以得知findState.subscriberClass = findState.clazz = subscriberClass != null,所以findUsingInfo會進入while循環。進入循環后，這里有一個很重要的動作就是：getSubscriberInfo
private SubscriberInfo getSubscriberInfo(FindState findState) {
···
···
//由EventBusBuillder從apt自動生成的類中獲取
if (subscriberInfoIndexes != null) {
for (SubscriberInfoIndex index : subscriberInfoIndexes) {
//取得Subscriber類的相關信息：Subscriber類，@Subscribe相關方法等
SubscriberInfo info = index.getSubscriberInfo(findState.clazz);
if (info != null) {
return info;
}
}
}
return null;
}
//SubscriberMethodFinder
private List<SubscriberInfoIndex> subscriberInfoIndexes;
如果subscriberInfoIndexes != null，那么就可以從其得到SubscriberInfo。看到這里，我們就有疑問了，你說subscriberInfoIndexes != null，那么它是在哪被賦值的呀？這里，我們就來回顧一下了，因為subscriberInfoIndexes是SubscriberMethodFinder類的成員變量，所以很自然我們會找一些SubscriberMethodFinder在哪里會對subscriberInfoIndexes進行賦值，
SubscriberMethodFinder(List<SubscriberInfoIndex> subscriberInfoIndexes, boolean strictMethodVerification,
boolean ignoreGeneratedIndex) {
this.subscriberInfoIndexes = subscriberInfoIndexes;
this.strictMethodVerification = strictMethodVerification;
this.ignoreGeneratedIndex = ignoreGeneratedIndex;
}
查看后，我們知道SubscriberMethodFinder是在構造函數中對subscriberInfoIndexes進行賦值，那么我們接下來應該尋找的就是SubscriberMethodFinder是在哪里被實例化，還記得我們EventBus.register里面有一句：
subscriberMethodFinder.findSubscriberMethods(subscriberClass);
原來SubscriberMethodFinder的一個實例化就在EventBus中，那么我們就來查看下EventBus具體在哪個地方對其進行創建:
EventBus(EventBusBuilder builder) {
subscriptionsByEventType = new HashMap<>();
typesBySubscriber = new HashMap<>();
stickyEvents = new ConcurrentHashMap<>();
mainThreadPoster = new HandlerPoster(this, Looper.getMainLooper(), 10);
backgroundPoster = new BackgroundPoster(this);
asyncPoster = new AsyncPoster(this);
indexCount = builder.subscriberInfoIndexes != null ? builder.subscriberInfoIndexes.size() : 0;
//index speed
subscriberMethodFinder = new SubscriberMethodFinder(builder.subscriberInfoIndexes,
builder.strictMethodVerification, builder.ignoreGeneratedIndex);
logSubscriberExceptions = builder.logSubscriberExceptions;
logNoSubscriberMessages = builder.logNoSubscriberMessages;
sendSubscriberExceptionEvent = builder.sendSubscriberExceptionEvent;
sendNoSubscriberEvent = builder.sendNoSubscriberEvent;
throwSubscriberException = builder.throwSubscriberException;
eventInheritance = builder.eventInheritance;
executorService = builder.executorService;
}
可以看到，SubscriberMethodFinder是在EventBus構造函數中被實例化的，然后SubscriberMethodFinder.subscriberInfoIndexes指向的是builder.subscriberInfoIndexes，而EventBusBuilder是通過addIndex()對subscriberInfoIndexes進行創建賦值的。
/** Adds an index generated by EventBus' annotation preprocessor. */
public EventBusBuilder addIndex(SubscriberInfoIndex index) {
if(subscriberInfoIndexes == null) {
subscriberInfoIndexes = new ArrayList<>();
}
subscriberInfoIndexes.add(index);
return this;
}
所以，如果想讓EventBus從apt中進行數據獲取，還要通過顯示構建一個EventBusBuilder，并調用
EventBus.builder().addIndex(new MyEventBusIndex()).build()方法進行創建賦值。
具體的做法如下：參考官方文檔
現在讓我們回到findUsingInfo方法中，如果getSubscriberInfo == null，那么它也會通過反射進行事件信息獲取。也就是說，如果你本意想通過apt進行數據獲取，但是可能由于不小心缺少了相應步驟配置，導致無法從apt獲取，那么，程序會自動采用反射進行獲取。結果是可以成功運行的，只是效率低了許多。
現在假設我們成功配置了apt，那么findUsingInfo就會進入下面代碼:
while (findState.clazz != null) {
findState.subscriberInfo = getSubscriberInfo(findState);
if (findState.subscriberInfo != null) {
SubscriberMethod[] array = findState.subscriberInfo.getSubscriberMethods();
for (SubscriberMethod subscriberMethod : array) {
if (findState.checkAdd(subscriberMethod.method, subscriberMethod.eventType)) {
findState.subscriberMethods.add(subscriberMethod);
}
}
}
···
findState.moveToSuperclass();
}
這部分代碼最終就會獲取到subscriberClass及其父類的@Subscribe方法存放到 findState.subscriberMethods中，最終返回給上層調用。
以上，查找事件信息過程就已結束了。
接下來，我們來看下subscribe過程:
/**
*
* @param subscriber
* @param subscriberMethod
* Map<Class<?>, CopyOnWriteArrayList<Subscription>> subscriptionsByEventType;
* subscriptionsByEventType中存儲的就是事件對應的監聽組信息。
* 由事件獲取得到監聽組，然后新的subscriber和SubscriberMethod按priority存放進同一event的
* CopyOnWriteArrayList<Subscription>中.
*
* 如果當前的Subscriber事件方法是sticky的,則從stickyEvents記錄中查找看是否有與本方法事件
* 相同的事件（即之前已經有組件發送該粘性事件{@link #postSticky(Object)}，如果有，則立即
* 調用本方法。
*/
// Must be called in synchronized block
private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
Class<?> eventType = subscriberMethod.eventType;
Subscription newSubscription = new Subscription(subscriber, subscriberMethod);
CopyOnWriteArrayList<Subscription> subscriptions = subscriptionsByEventType.get(eventType);
if (subscriptions == null) {
subscriptions = new CopyOnWriteArrayList<>();
subscriptionsByEventType.put(eventType, subscriptions);
} else {
if (subscriptions.contains(newSubscription)) {
throw new EventBusException("Subscriber " + subscriber.getClass() + " already registered to event "
+ eventType);
}
}
int size = subscriptions.size();
for (int i = 0; i <= size; i++) {
if (i == size || subscriberMethod.priority > subscriptions.get(i).subscriberMethod.priority) {
subscriptions.add(i, newSubscription);
break;
}
}
//記錄subscriber對應的所有事件類型
List<Class<?>> subscribedEvents = typesBySubscriber.get(subscriber);
if (subscribedEvents == null) {
subscribedEvents = new ArrayList<>();
typesBySubscriber.put(subscriber, subscribedEvents);
}
subscribedEvents.add(eventType);
if (subscriberMethod.sticky) {
if (eventInheritance) {
// Existing sticky events of all subclasses of eventType have to be considered.
// Note: Iterating over all events may be inefficient with lots of sticky events,
// thus data structure should be changed to allow a more efficient lookup
// (e.g. an additional map storing sub classes of super classes: Class -> List<Class>).
Set<Map.Entry<Class<?>, Object>> entries = stickyEvents.entrySet();
for (Map.Entry<Class<?>, Object> entry : entries) {
Class<?> candidateEventType = entry.getKey();
//candidateEventType跟eventType是否是同一類型
if (eventType.isAssignableFrom(candidateEventType)) {
Object stickyEvent = entry.getValue();
checkPostStickyEventToSubscription(newSubscription, stickyEvent);
}
}
} else {
Object stickyEvent = stickyEvents.get(eventType);
checkPostStickyEventToSubscription(newSubscription, stickyEvent);
}
}
}
可以看出，subscribe過程主要做了3件事：
1.將當前的subscriberMethod按priority添加到subscriptionsByEventType中的同一evenType中
2.將當前事件eventType添加到當前subscriber的事件集合中，映射關系表由typesBySubscriber記錄
3.如果當前事件是粘性事件，那么從系統保存的粘性發送事件stickyEvents中，找尋與當前事件相同（或與當前事件類型有繼承關系）的事件，取出事件參數，并立即調用當前事件方法，傳入事件參數。
最后，以一張圖來顯示register過程:
(2). 事件分發
接下來，我們來看一下EventBus的事件分發過程:
/** Posts the given event to the event bus. */
public void post(Object event) {
//取得post線程當前狀態
PostingThreadState postingState = currentPostingThreadState.get();
List<Object> eventQueue = postingState.eventQueue;
//為當前線程增加一個分發事件
eventQueue.add(event);
//當前線程未處于分發狀態
if (!postingState.isPosting) {
postingState.isMainThread = Looper.getMainLooper() == Looper.myLooper();
postingState.isPosting = true;
if (postingState.canceled) {
throw new EventBusException("Internal error. Abort state was not reset");
}
try {
//分發當前線程所有事件
while (!eventQueue.isEmpty()) {
postSingleEvent(eventQueue.remove(0), postingState);
}
} finally {
postingState.isPosting = false;
postingState.isMainThread = false;
}
}
}
可以看到，post過程首先做的是取出當前線程的線程狀態，currentPostingThreadState是一個ThreadLocal對象，這樣可以很好的保證在不同的線程中都擁有一份線程獨立的PostingThreadState對象。
post過程首先取出當前線程狀態對象:PostingThreadState postingState ,然后將當前分發的事件添加進線程對象postingState中，最后，如果當前線程不處于分發狀態，那么就循環遍歷當前線程所有分發事件，取出事件進行分發。分發函數為：postSingleEvent
private void postSingleEvent(Object event, PostingThreadState postingState) throws Error {
Class<?> eventClass = event.getClass();
boolean subscriptionFound = false;
//eventInheritance:是否支持事件繼承分發，默認為true
if (eventInheritance) {
//存儲eventClass及其父類/接口，
// 即發送一個事件，那么注冊該事件以及該事件的父類/接口的訂閱者都會收到該事件通知
List<Class<?>> eventTypes = lookupAllEventTypes(eventClass);
int countTypes = eventTypes.size();
for (int h = 0; h < countTypes; h++) {
Class<?> clazz = eventTypes.get(h);
subscriptionFound |= postSingleEventForEventType(event, postingState, clazz);
}
} else {
subscriptionFound = postSingleEventForEventType(event, postingState, eventClass);
}
//如果分發的事件沒有對應的訂閱者
if (!subscriptionFound) {
if (logNoSubscriberMessages) {
Log.d(TAG, "No subscribers registered for event " + eventClass);
}
//則發送一個NoSubscriberEvent事件
if (sendNoSubscriberEvent && eventClass != NoSubscriberEvent.class &&
eventClass != SubscriberExceptionEvent.class) {
post(new NoSubscriberEvent(this, event));
}
}
}
postSingleEvent為單個事件分發流程，eventInheritance標志事件是否支持繼承分發，默認為true（可以在EventBusBuilder中查看到），即EventBus默認會分發該事件到注冊該事件或者該事件父類/接口的訂閱者事件函數中。所以，postSingleEvent主要做了2件事:
1.判斷是否支持事件繼承分發：如果支持，那么就通過當前事件class對象，找到其父類/接口所有事件類型，然后循環取出每個事件類別，依次調用postSingleEventForEventType進行實際的事件分發；如果不支持事件繼承分發，那么就直接將當前事件分發給當前事件訂閱者。
2.如果當前分發事件沒有對應的訂閱者，那么就會發送一個NoSubscriberEvent事件給到當前事件總線。
而將事件分發給訂閱者，主要做了哪些事呢？讓我們看一下源碼:
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) {
postingState.event = event;
postingState.subscription = subscription;
boolean aborted = false;
try {
postToSubscription(subscription, event, postingState.isMainThread);
aborted = postingState.canceled;
} finally {
postingState.event = null;
postingState.subscription = null;
postingState.canceled = false;
}
if (aborted) {
break;
}
}
return true;
}
return false;
}
原來，事件分發給訂閱者主要做的就是：從之前register的訂閱者事件集合subscriptionsByEventType中，通過當前事件，得到對應的訂閱者集合，結合當前的post線程對象狀態，依次調用postToSubscription真正地將事件分發給各個訂閱者。
我們知道，在使用EventBus過程中，我們可以在不同的線程post事件，然后訂閱該事件的事件函數會根據threadMode會自動進行線程切換，那這是怎樣做到的呢？想了解清楚這點，那么我們就要看一下postToSubscription函數了:
private void postToSubscription(Subscription subscription, Object event, boolean isMainThread) {
switch (subscription.subscriberMethod.threadMode) {
case POSTING:
invokeSubscriber(subscription, event);
break;
case MAIN:
if (isMainThread) {
invokeSubscriber(subscription, event);
} else {
mainThreadPoster.enqueue(subscription, event);
}
break;
case BACKGROUND:
if (isMainThread) {
backgroundPoster.enqueue(subscription, event);
} else {
invokeSubscriber(subscription, event);
}
break;
case ASYNC:
asyncPoster.enqueue(subscription, event);
break;
default:
throw new IllegalStateException("Unknown thread mode: " + subscription.subscriberMethod.threadMode);
}
}
這里，我們可以看到，postToSubscription會根據每個訂閱者的事件函數的threadMode標識，對應當前線程狀態，進行線程間轉換，從而保證了訂閱者事件函數會運行在與threadMode指定的線程中。
從源碼中，我們可以看到，具體的threadMode所對應的線程為：
- POSTING：訂閱者事件函數運行在與post線程同一線程。
- MAIN：如果post線程是主線程，那么直接調用訂閱者事件函數；如果post不是在主線程，那么通過mainThreadPoster將訂閱者函數切換到主線程上運行。
- BACKGROUND：如果調用者是主線程，那么通過backgroundPoster將訂閱者事件函數切換到后臺線程上運行，反之則在post線程上直接運行。
- ASYNC：無論post處于哪個線程，都會直接重開一條線程執行訂閱者函數。
我們看到，post事件后，如果是處于同一條執行線程，EventBus是通過invokeSubscriber()函數讓訂閱者函數得到回調，具體做法如下：
void invokeSubscriber(Subscription subscription, Object event) {
try {
subscription.subscriberMethod.method.invoke(subscription.subscriber, event);
} catch (InvocationTargetException e) {
handleSubscriberException(subscription, event, e.getCause());
} catch (IllegalAccessException e) {
throw new IllegalStateException("Unexpected exception", e);
}
}
其實就是通過反射進行方法調用。
然后如果是要進行線程切換回調訂閱者事件函數，則是采用各種Poster的enqueue方法，那么，我們接下來就來看下它們是具體怎樣進行線程切換的。
- ** 切換到主線程：mainThreadPoster.enqueue(subscription, event)**
首先，mainThreadPoster是一個HandlerPoster對象:
final class HandlerPoster extends Handler {
private final PendingPostQueue queue;
private final int maxMillisInsideHandleMessage;
private final EventBus eventBus;
private boolean handlerActive;
HandlerPoster(EventBus eventBus, Looper looper, int maxMillisInsideHandleMessage) {
super(looper);
this.eventBus = eventBus;
this.maxMillisInsideHandleMessage = maxMillisInsideHandleMessage;
queue = new PendingPostQueue();
}
void enqueue(Subscription subscription, Object event) {
PendingPost pendingPost = PendingPost.obtainPendingPost(subscription, event);
synchronized (this) {
queue.enqueue(pendingPost);
if (!handlerActive) {
handlerActive = true;
if (!sendMessage(obtainMessage())) {
throw new EventBusException("Could not send handler message");
}
}
}
}
@Override
public void handleMessage(Message msg) {
boolean rescheduled = false;
try {
long started = SystemClock.uptimeMillis();
while (true) {
PendingPost pendingPost = queue.poll();
if (pendingPost == null) {
synchronized (this) {
// Check again, this time in synchronized
pendingPost = queue.poll();
if (pendingPost == null) {
handlerActive = false;
return;
}
}
}
eventBus.invokeSubscriber(pendingPost);
long timeInMethod = SystemClock.uptimeMillis() - started;
if (timeInMethod >= maxMillisInsideHandleMessage) {
if (!sendMessage(obtainMessage())) {
throw new EventBusException("Could not send handler message");
}
rescheduled = true;
return;
}
}
} finally {
handlerActive = rescheduled;
}
}
}
在回顧下EventBus的構造函數，可以看到:
EventBus(EventBusBuilder builder) {
···
···
mainThreadPoster = new HandlerPoster(this, Looper.getMainLooper(), 10);
···
···
可以看到，mainThreadPoster就是一個主線程的Handler，然后再enqueue的時候,先用一個PendingPost保存一下當前的訂閱者信息和事件，并存儲到一個queue中，然后通過sendMessage(）給自己發了一個消息，那么自然handleMessage()就會得到回掉，然后在HandlerPoster的handleMessage中可以看到，它通過在queue中獲取先前存入的事件信息后，調用了eventBus.invokeSubscriber(pendingPost)：
void invokeSubscriber(PendingPost pendingPost) {
Object event = pendingPost.event;
Subscription subscription = pendingPost.subscription;
PendingPost.releasePendingPost(pendingPost);
if (subscription.active) {
invokeSubscriber(subscription, event);
}
}
所以invokeSubscriber最終也是采用發射的方式調用到了訂閱者的事件函數，而且由于是在主線程Handler的handlerMessage中調用，那么訂閱者事件函數肯定是運行在主線程中的。
- ** 切換到后臺線程: backgroundPoster.enqueue(subscription, event)**
backgroundPoster是一個BackgroundPoster對象:
final class BackgroundPoster implements Runnable {
public void enqueue(Subscription subscription, Object event) {
PendingPost pendingPost = PendingPost.obtainPendingPost(subscription, event);
synchronized (this) {
queue.enqueue(pendingPost);
if (!executorRunning) {
executorRunning = true;
eventBus.getExecutorService().execute(this);
}
}
}
@Override
public void run() {
while (true) {
PendingPost pendingPost = queue.poll(1000);
···
eventBus.invokeSubscriber(pendingPost);
···
executorRunning = false;
}
}
以上代碼經過簡化，可以看到BackgroundPoster就是一個Runnable，然后enqueue的時候，也是把訂閱者相關信息和事件存儲到一個PendingPost 中，最后通過線程池的方式執行自身，那么自己的run()方法就會得到調用，而run()方法里面做的就是從queue中獲取數據，最后調用方式方式回調訂閱者事件函數。這里有一點要注意的就是，BackgroundPoster在線程池執行一個任務時，executorRunning是會被置成true的，完成一個任務后，才會被重置成false，也就是說，BackgroundPoster的任務是串行運行的。
- ** 新開線程:asyncPoster.enqueue(subscription, event)**
asyncPoster是一個AsyncPoster對象：
/**
* Posts events in background.
*
* @author Markus
*/
class AsyncPoster implements Runnable {
private final PendingPostQueue queue;
private final EventBus eventBus;
AsyncPoster(EventBus eventBus) {
this.eventBus = eventBus;
queue = new PendingPostQueue();
}
public void enqueue(Subscription subscription, Object event) {
PendingPost pendingPost = PendingPost.obtainPendingPost(subscription, event);
queue.enqueue(pendingPost);
eventBus.getExecutorService().execute(this);
}
@Override
public void run() {
PendingPost pendingPost = queue.poll();
if(pendingPost == null) {
throw new IllegalStateException("No pending post available");
}
eventBus.invokeSubscriber(pendingPost);
}
}
從AsyncPoster源碼中可以看到，其實現機制與BackgroundPoster是基本一致的。唯一值得注意的是，AsyncPoster來一個任務就立即執行，也就是說AsyncPoster的任務是并行運行的。
綜上:對于EventBus的線程切換邏輯，他們的做法其實原理基本一致：
都是通過將訂閱者相關信息和事件存儲到一個隊列里面，然后再異步從相關回調（對于Handler來說就是handlerMessage(),對于線程池來說就是Runnable.run()）中，反射執行訂閱者事件函數，從而達成線程切換這一功能。
用一張圖來說明下post過程:
register,post都講了，最后，再說一下unregister就圓滿了。
(3). 解除訂閱
unregister過程:
/** Unregisters the given subscriber from all event classes. */
public synchronized void unregister(Object subscriber) {
List<Class<?>> subscribedTypes = typesBySubscriber.get(subscriber);
if (subscribedTypes != null) {
for (Class<?> eventType : subscribedTypes) {
unsubscribeByEventType(subscriber, eventType);
}
typesBySubscriber.remove(subscriber);
} else {
Log.w(TAG, "Subscriber to unregister was not registered before: " + subscriber.getClass());
}
}
/** Only updates subscriptionsByEventType, not typesBySubscriber! Caller must update typesBySubscriber. */
private void unsubscribeByEventType(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--;
}
}
}
}
源碼中可以看出，unregister主要就是做了2件事:
- 由訂閱者subscriber從typesBySubscriber中取出當前訂閱者訂閱的所有事件集合。
-
遍歷訂閱事件，依次取出一個事件，然后從subscriptionsByEventType中獲得所有訂閱該事件的訂閱者集合，從中找到該取消注冊的subscriber，將其active狀態設為false，并從該事件集合中刪除。
EventBus::unregister
最后，文字總結下：
Register過程：
注冊過程主要執行2個操作:
- 由當前訂閱者subscriber，通過apt或者反射方式獲取當前subscriber及其父類事件訂閱函數(@Subscribe).
- subscribe過程，subscribe就是訂閱者的注冊過程，該過程會將當前訂閱者與其（及其父類）訂閱方法記錄起來，主要做以下4大操作：
1). 依據上面獲取到的事件集合，對每一個事件進行操作。依據事件類別，從subscriptionsByEventType取出所有訂閱該事件的訂閱者集合（沒有訂閱，則進行記錄創建）。
2). 依據當前事件的priority插入到訂閱者集合中，從而實現優先級事件。
3). 將當前事件存儲到當前訂閱者subscriber的事件集合中，方便后續unregister（依據subscriber獲取得到subscriber的事件集合，再遍歷事件集合，從各個事件注冊集合中，刪除該subscriber）。
4). 如果當前事件是sticky事件，那么就從stickyEvents集合中(postSticky()會記錄事件類型和事件實例)獲取得到事件實例，并讓當前訂閱者subscriber進行調用。
Post過程：
post過程就是一個事件分發過程，其最基礎的元素就是事件。
post一個事件的時候，主要經歷以下4大歷程：
- 將當前事件添加到當前線程狀態事件列表中
- 循環取出當前線程事件，依次進行事件分發：
- 如果當前事件總線支持事件繼承分發，那么就獲取當前事件及其所有父類/接口類別，存儲到集合中，然后遍歷集合，依次按照事件類別進行分發；
- 如果當前事件總線不支持事件繼承分發，那么直接將當前事件進行分發；
- 如果未找到當前事件訂閱者（沒有訂閱），則post一個NoSubscriberEvent事件
- 根據當前事件類別，進行事件分發。事件分發首先從注冊記錄中找到該事件類別的訂閱者集合，然后遍歷訂閱者集合，進行單個訂閱者事件分發。
- 進行單個訂閱者事件分發會依據訂閱者事件函數threadMode以及當前線程狀態（是否是mainThread)，自動進行線程切換。
Unregister過程：
unregister過程主要也是由2個操作：
- 由當前要unregister的訂閱者subscriber，獲取得到其訂閱的所有事件集合。
- 遍歷上面得到的事件集合，依據事件從subscriptionsByEventType中取出所有訂閱了該事件的訂閱者集合，從中找到這個要unregister的訂閱者，將其active狀態設為false，并從事件集合中進行刪除，這樣，就完成了unregister過程。
附錄
to be continue
