EventBus 是一种 publish/subscribe 事件总线，适用于 Android和Java.
EventBus 涉及两个步骤，
- register 就是注册事件接收者，
- post publish事件。
register(Test.this), 将Test类中所有定义了@subscribe的函数通过反射查找出放到一个subscriptionsByEventType Map中, 该Map的key是Event Type类型，如图中所示，分别为 Bar.class和Foo.class. 而该 Map的 Value对应的是一个List, 也就是说同一种Event Type可以定义多个接收函数, 这些接收函数存放在一个List里，最后保存到Map里。
post(new Bar()), Publish一个Event Type为 Bar对象，从subscriptionsByEventType Map通过Bar.class找到用于接收 Bar 事件的List, 最后对List里所有的方法根据订阅时的规则依次执行。
还有一个比较重要的结构体是 typesBySubscriber 该Map主要是用于记录一个类比如 Test.class 是否已经注册过了。
EventBus调用注册函数的几种方法。
EventBus在Post一个事件类型后，对应注册该类型的接收函数就会被调用，而调用时可以会几种不同的方式，主要是由注册函数定义的线程模型决定.
post -> postSingleEvent -> postSingleEventForEventType -> 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 MAIN_ORDERED:
if (mainThreadPoster != null) {
mainThreadPoster.enqueue(subscription, event);
} else {
// temporary: technically not correct as poster not decoupled from subscriber
invokeSubscriber(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);
}
}
POSTING
定义成POSTING的接收函数，当事件发生时，就在EventBus.getDefault().post()所在的线程中调用.MAIN
如果当前是Main线程, 直接调用该注册方法。如果当前不是Main线程，则将该注册方法通过主线程的Handler post到主线程去执行。MAIN_ORDERED
MAIN_ORDERED与MAIN的区别在于，不管三七二十一，把注册方法post到主线程中，这样如果当前是主线程的话，注册接收的方法不会立即执行，而是放在主线程所有的Message的最后去执行。BACKGROUND
如果当前是主线程，则将注册方法 post到background线程中去执行。如果当前是非主线程，则直接调用ASYNC
Async线程类型，将注册方法post到线程池中去执行。
BACKGROUND与ASYNC的区别
class AsyncPoster implements Runnable, Poster {
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);
}
}
final class BackgroundPoster implements Runnable, Poster {
private final PendingPostQueue queue;
private final EventBus eventBus;
private volatile boolean executorRunning;
BackgroundPoster(EventBus eventBus) {
this.eventBus = eventBus;
queue = new PendingPostQueue();
}
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() {
try {
try {
while (true) {
PendingPost pendingPost = queue.poll(1000);
if (pendingPost == null) {
synchronized (this) {
// Check again, this time in synchronized
pendingPost = queue.poll();
if (pendingPost == null) {
executorRunning = false;
return;
}
}
}
eventBus.invokeSubscriber(pendingPost);
}
} catch (InterruptedException e) {
eventBus.getLogger().log(Level.WARNING, Thread.currentThread().getName() + " was interruppted", e);
}
} finally {
executorRunning = false;
}
}
}
BACKGROUND与ASYNC都继承于Runnable, 执行时都是通过线程池去调用执行，而它们的区别在于，对于ASYNC的方式，都是直接提交线程池直接执行，意思是，如果当前有多个注册的事件都是ASYNC,而这些事件都发生了，那它们都会同时在线程池中被调用。意思是多线程运行。
而BACKGROUND线程，当注册的BACKGROUND事件同时发生时，它们会被enqueue到同一个线程中去依次执行。当前，这个同时是有时间限制，BACKGROUND线程去poll在1s，如果没有事件时，它会退出去， 如果这时BACKGROUND再次发生时，此时BACKGROUND可能运行于线程池中另一个线程，而非之前那个线程，不过所有BACKGROUND的事件都是依次在一个线程中执行，而这一个线程并不是真正意义上的一个线程。
