1. EventBus简介
EventBus是基于观察者模式实现的事件发布/订阅框架，主要运用于Android中各组件间的通信。
与其他通信方式比较，EventBus的优点是实现简单，使用方便，充分解耦，不易出错.
EventBus中有三个概念（其实也是观察者模式中的概念）：
- 事件：可以为任意类型
- 事件订阅者：用
@Subscribe注解修饰的方法 - 事件发布者：可以在任意线程使用EventBus的post方法进行事件的发布
2. EventBus使用
2.1 定义一个自己的事件类
// EventBus传递的事件可以是任意对象
public class MyEvent {
public String mContent;
public int mId;
public MyEvent(String content, int id) {
mContent = content;
mId = id;
}
}
2.2 定义一个接收事件的方法并注册到EventBus中
public class MainActivity extends AppCompatActivity {
// 在onCreate方法中注册
@Override
protected void onCreate(Bundle savedInstanceState) {
...
EventBus.getDefault().register(this);
}
// 记得在onDestroy方法中注销
@Override
protected void onDestroy() {
EventBus.getDefault().unregister(this);
}
/**
* 定义一个接收事件后具体执行的方法，需要用@Subscribe注解修饰，参数就是该方法注册的事件类型；
* 其实在这里可以大致猜出EventBus在register方法中做了什么：通过反射找到所有被@Subscribe注解修饰的方法，将其保存起来；
* 等到其他地方post了对应的事件（即与该方法参数类型相同），EventBus找到对应的method，然后调用method.invoke()方法，从而实现事件的发布。
**/
@Subscribe(threadMode = ThreadMode.MAIN, sticky = true, priority = 1)
public void dealMyEvent(MyEvent event) {
...
}
}
2.3 在其他地方发送事件
// 在其他组件中调用post或者postSticky方法发送事件
// 黏性事件会被EventBus保存起来，即使订阅者在事件发布之后订阅，依然能够收到该黏性事件；而普通事件则不行。
EventBus.getDefault().post(new MyEvent("This message from another Activity!", 1));
EventBus.getDefault().postSticky(new MyEvent("This message from another Activity", 2));
3. EventBus源码阅读
接下来就从EventBus.getDefault().register()开始，看一看EventBus是如何只通过一个注解@Subscribe，来完成事件的发布/订阅的。
3.1 注册
首先是EventBus.getDefault()：
static volatile EventBus defaultInstance;
public static EventBus getDefault() {
if (defaultInstance == null) {
synchronized(EventBus.class) {
if (defaultInstance == null) {
defaultInstance = new EventBus();
}
}
}
return defaultInstance;
}
getDefault()方法通过单例模式，生成一个全局唯一的EventBus实例。一般这种情况下，构造方法都是private的，但是EventBus的构造方法是public的。
public void register(Object subscriber) {
Class<?> subscriberClass = subscriber.getClass();
List<SubscriberMethod> subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);
synchronized (this) {
for (SubscriberMethod subscriberMethod : subscriberMethods) {
subscribe(subscriber, subscriberMethod);
}
}
}
register方法分为两步：第一，找到需要注册的subscriber对象中被@Subscribe注解修饰的方法；第二，通过subscribe方法将其注册到EventBus中。
3.1.1 SubscriberMethodFinder类
这个类是用来寻找订阅者注册到EventBus中的方法。
3.1.1.1 SubscriberMethod
SubscriberMethod类是封装被@Subscribe注解修饰的方法，保存了注解中ThreadMode、priority、sticky等值。
public class SubscriberMethod {
//执行事件的方法
final Method method;
//该方法需要在哪种模式下执行
final ThreadMode threadMode;
//事件类型
final Class<?> eventType;
//优先级
final int priority;
//是否粘性事件
final boolean sticky;
//todo:
String methodString;
}
3.1.1.2 findSubscriberMethods()
List<SubscriberMethod> findSubscriberMethods(Class<?> subscriberClass) {
//先检查缓存中有没有，如果有，就直接返回。
List<SubscriberMethod> subscriberMethods = METHOD_CACHE.get(subscriberClass);
if (subscriberMethods != null) {
return subscriberMethods;
}
if (ignoreGeneratedIndex) {
//通过反射，见3.1.1.3
subscriberMethods = findUsingReflection(subscriberClass);
} else {
// 该方法不通过注解，而是通过注解处理器去注册方法，如果不做相关设置的话，在该方法内部依然调用的是findUsingReflectionInSingleClass方法
subscriberMethods = findUsingInfo(subscriberClass);
}
//如果在该类中没有找到方法，则抛出异常
if (subscriberMethods.isEmpty()) {
throw new EventBusException("Subscriber " + subscriberClass
+ " and its super classes have no public methods with the @Subscribe annotation");
} else {
//将其缓存起来
METHOD_CACHE.put(subscriberClass, subscriberMethods);
return subscriberMethods;
}
}
3.1.1.3 findUsingReflection方法
private List<SubscriberMethod> findUsingReflection(Class<?> subscriberClass) {
//FindState当作查找处理方法的工具类，保存查找过程中的状态和中间值等
FindState findState = prepareFindState();
findState.initForSubscriber(subscriberClass);
while (findState.clazz != null) {
//调用此方法来完成方法的查找，见3.1.1.4
findUsingReflectionInSingleClass(findState);
// 迭代其父类
findState.moveToSuperclass();
}
// 拿到findState中找到的处理方法
return getMethodsAndRelease(findState);
}
3.1.1.4 findUsingReflectionInSingleClass
private void findUsingReflectionInSingleClass(FindState findState) {
Method[] methods;
try {
//官方在这里注释，说比getMethods方法更快，尤其是当订阅者为Activities这种比较庞大的类。
methods = findState.clazz.getDeclaredMethods();
} catch (Throwable th) {
// Workaround for java.lang.NoClassDefFoundError, see https://github.com/greenrobot/EventBus/issues/149
methods = findState.clazz.getMethods();
findState.skipSuperClasses = true;
}
for (Method method : methods) {
int modifiers = method.getModifiers();
//从这里可以看出对方法的要求：必须是public，并且不能是abstract、static、bridge、synthetic
if ((modifiers & Modifier.PUBLIC) != 0 && (modifiers & MODIFIERS_IGNORE) == 0) {
Class<?>[] parameterTypes = method.getParameterTypes();
//必须拥有一个参数，决定了该方法可以接收哪种类型的事件
if (parameterTypes.length == 1) {
Subscribe subscribeAnnotation = method.getAnnotation(Subscribe.class);
if (subscribeAnnotation != null) {
Class<?> eventType = parameterTypes[0];
//checkAdd方法做了一些判断，见3.1.1.5
if (findState.checkAdd(method, eventType)) {
//取出注解中各参数的值，生成SubscriberMethod
ThreadMode threadMode = subscribeAnnotation.threadMode();
findState.subscriberMethods.add(new SubscriberMethod(method, eventType, threadMode,
subscribeAnnotation.priority(), subscribeAnnotation.sticky()));
}
}
} else if (strictMethodVerification && method.isAnnotationPresent(Subscribe.class)) {
String methodName = method.getDeclaringClass().getName() + "." + method.getName();
throw new EventBusException("@Subscribe method " + methodName +
"must have exactly 1 parameter but has " + parameterTypes.length);
}
} else if (strictMethodVerification && method.isAnnotationPresent(Subscribe.class)) {
String methodName = method.getDeclaringClass().getName() + "." + method.getName();
throw new EventBusException(methodName +
" is a illegal @Subscribe method: must be public, non-static, and non-abstract");
}
}
}
3.1.1.5 checkAdd方法
static class FindState {
final Map<Class, Object> anyMethodByEventType = new HashMap<>();
final Map<String, Class> subscriberClassByMethodKey = new HashMap<>();
boolean checkAdd(Method method, Class<?> eventType) {
// 一般情况下，一个订阅者中对某一事件的处理方法只有一个，所以existing多数情况下都为null，直接保存到anyMethodByEventType中；
// 当同一订阅者中对某一事件的处理方法有多个时，或者在其父类中也包含对该事件的处理方法时，之后注册的处理方法，existing就不为null，
Object existing = anyMethodByEventType.put(eventType, method);
if (existing == null) {
return true;
} else {
// 如果existing为Method，表明参数method是该订阅者中第2个对eventType的处理方法
if (existing instanceof Method) {
if (!checkAddWithMethodSignature((Method) existing, eventType)) {
// Paranoia check
throw new IllegalStateException();
}
// 将eventType对应的value改为this，将method与existing都保存到subscriberClassByMethodKey中
anyMethodByEventType.put(eventType, this);
}
return checkAddWithMethodSignature(method, eventType);
}
}
private boolean checkAddWithMethodSignature(Method method, Class<?> eventType) {
methodKeyBuilder.setLength(0);
methodKeyBuilder.append(method.getName());
methodKeyBuilder.append('>').append(eventType.getName());
// 方法名>eventType
String methodKey = methodKeyBuilder.toString();
Class<?> methodClass = method.getDeclaringClass();
Class<?> methodClassOld = subscriberClassByMethodKey.put(methodKey, methodClass);
// 当子类继承的某个方法和父类中该方法都被`@Subscribe`注解修饰，这种情况下:
// 1. methodClassOld不为null；
// 2. 由于EventBus寻找处理事件的方法的顺序是先找子类，再找父类，所以methodClassOld为子类，methodClassOld.isAssignableFrom(methodClass)为false
// 这种情况下，会忽略掉父类中的处理方法，仅保存子类中的
if (methodClassOld == null || methodClassOld.isAssignableFrom(methodClass)) {
return true;
} else {
subscriberClassByMethodKey.put(methodKey, methodClassOld);
return false;
}
}
}
3.1.2 subscribe方法的处理
// Subscription类是对订阅者的封装，内部包含了订阅对象和处理事件的方法。
final class Subscription {
final Object subscriber;
final SubscriberMethod subscriberMethod;
}
// EventBus中用两个HashMap来保存订阅者信息，一个是`subscriptionsByEventType`，一个是`typesBySubscriber`。
public class EventBus {
// key为事件类型，value为订阅该事件的所有订阅者信息
private final Map<Class<?>, CopyOnWriteArrayList<Subscription>> subscriptionsByEventType = new HashMap<>();
// key为订阅的对象，value为该对象所有注册到EventBus中的处理方法，用于注销
private final Map<Object, List<Class<?>>> typesBySubscriber = new HashMap<>();
}
// 该方法必须在同步块中调用
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 {
// 这里subscriptions是CopyOnWriteArrayList类型，在其constains方法的实现中，最终采用的是equals方法来比较两个对象是否相等；
// 这里即采用Subscription中的equals方法：
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;
}
}
// 这里将订阅者对象所有注册的处理函数保存起来
List<Class<?>> subscribedEvents = typesBySubscriber.get(subscriber);
if (subscribedEvents == null) {
subscribedEvents = new ArrayList<>();
typesBySubscriber.put(subscriber, subscribedEvents);
}
subscribedEvents.add(eventType);
// 接下来是对粘性事件的处理，见3.1.3
...
}
3.1.3 粘性事件的处理
private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
...
// 如果该事件处理方法接收黏性事件
if (subscriberMethod.sticky) {
// 这里根据是否处理该事件类型的子类型分为两种情况：
// 1. 不处理，那么从黏性事件中取出该类型事件，调用checkPostStickyEventToSubscription方法处理
// 2. 处理，那么从黏性事件Map中，取出所有该事件以及该事件类型的子类事件，一一交由checkPostStickyEventToSubscription方法处理
if (eventInheritance) {
Set<Map.Entry<Class<?>, Object>> entries = stickyEvents.entrySet();
for (Map.Entry<Class<?>, Object> entry : entries) {
Class<?> candidateEventType = entry.getKey();
if (eventType.isAssignableFrom(candidateEventType)) {
Object stickyEvent = entry.getValue();
checkPostStickyEventToSubscription(newSubscription, stickyEvent);
}
}
} else {
Object stickyEvent = stickyEvents.get(eventType);
checkPostStickyEventToSubscription(newSubscription, stickyEvent);
}
}
}
3.1.3.1 checkPostStickyEventToSubscription方法
private void checkPostStickyEventToSubscription(Subscription newSubscription, Object stickyEvent) {
if (stickyEvent != null) {
// 这里直接调用postToSubscription，也是真正处理事件的地方，见3.3
postToSubscription(newSubscription, stickyEvent, isMainThread());
}
}
3.2 注销
在组件生命周期结束的时候，一定不要忘记在EventBus中注销。
public synchronized void unregister(Object subscriber) {
List<Class<?>> subscribedTypes = typesBySubscriber.get(subscriber);
if (subscribedTypes != null) {
for (Class<?> eventType : subscribedTypes) {
// 从subscriptionsByEventTypes中移除掉所有的订阅者
unsubscribeByEventType(subscriber, eventType);
}
// 从typesBySubscriber中移除
typesBySubscriber.remove(subscriber);
} else {
logger.log(Level.WARNING, "Subscriber to unregister was not registered before: " + subscriber.getClass());
}
}
3.3 post()与postSticky()方法
3.3.1 post方法
post方法：从ThreadLocalMap取出PostingThreadState对象，将事件添加到eventQueue中，然后从eventQueue中循环拿出事件，交由postSingleEvent方法处理。
public void post(Object event) {
PostingThreadState postingState = currentPostingThreadState.get();
List<Object> eventQueue = postingState.eventQueue;
eventQueue.add(event);
if (!postingState.isPosting) {
postingState.isMainThread = isMainThread();
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;
}
}
}
3.3.1 PostingThreadState类
每个线程都保存有一个PostingThreadState对象在ThreadLocalMap里，该对象如下所示。
final static class PostingThreadState {
// 保存该线程post的事件
final List<Object> eventQueue = new ArrayList<>();
// 是否正在发送事件
boolean isPosting;
// 是否主线程
boolean isMainThread;
// 订阅者信息
Subscription subscription;
// 事件对象
Object event;
// 是否取消
boolean canceled;
}
3.3.2 postSingleEvent方法
postSingleEvent方法只做了一件事情：判断事件是否继承，如果允许继承，那么就找出该类的父类和接口，然后一一传递给postSingleEventForEventType方法。比如类Son继承自类Father，现在post了一个Son事件，如果允许继承，那么注册到EventBus中能够处理Father事件的订阅者，也能够接收到该Son事件
private void postSingleEvent(Object event, PostingThreadState postingState) throws Error {
Class<?> eventClass = event.getClass();
boolean subscriptionFound = false;
if (eventInheritance) {
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) {
logger.log(Level.FINE, "No subscribers registered for event " + eventClass);
}
if (sendNoSubscriberEvent && eventClass != NoSubscriberEvent.class &&
eventClass != SubscriberExceptionEvent.class) {
post(new NoSubscriberEvent(this, event));
}
}
}
3.3.3 postSingleEventForEventType方法
postSingleEventForEventType方法从subscriptionsByEventType中取出注册eventClass的订阅者，然后将其传递给postToSubscription方法
private boolean postSingleEventForEventType(Object event, PostingThreadState postingState, Class<?> eventClass) {
CopyOnWriteArrayList<Subscription> subscriptions;
synchronized (this) {
// 从subscriptionsByEventType中取出注册该事件的订阅者
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;
}
3.3.4 postToSubscription方法
经由post方法发送的事件，最终来到了postToSubscription方法。这个方法也是EventBus中根据不同ThreadMode最终事件分发的地方。
从代码中可以看到，一共有5种ThreadMode和3种Poster。
private void postToSubscription(Subscription subscription, Object event, boolean isMainThread) {
switch (subscription.subscriberMethod.threadMode) {
// POSTING模式表明事件处理函数和发送事件的线程为同一线程
case POSTING:
// 直接调用invokeSubscriber方法来执行事件处理函数
invokeSubscriber(subscription, event);
break;
// MAIN模式表明事件处理函数运行在主线程（UI线程）
case MAIN:
// 如果当前线程为Main线程，则直接调用invokeSubscriber方法来执行事件处理函数
if (isMainThread) {
invokeSubscriber(subscription, event);
} else {
// 如果当前线程不是Main线程，则将事件发送给mainThreadPoster
mainThreadPoster.enqueue(subscription, event);
}
break;
// MAIN_ORDERED模式同MAIN模式一样，事件处理函数运行在主线程，只不过这里是有序的，按照事件的发送时间。
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;
// BACKGROUND模式表示事件处理函数运行在后台进程
case BACKGROUND:
if (isMainThread) {
// 如果当前线程为主线程，则将事件发送给backgroundPoster
backgroundPoster.enqueue(subscription, event);
} else {
// 如果当前线程不是主线程，则直接调用invokeSubscriber方法执行事件处理函数
invokeSubscriber(subscription, event);
}
break;
// ASYNC模式表示事件是异步执行的，由asyncPoster实现
case ASYNC:
asyncPoster.enqueue(subscription, event);
break;
default:
throw new IllegalStateException("Unknown thread mode: " + subscription.subscriberMethod.threadMode);
}
}
3.3.5 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);
}
}
3.4 EventBus中的Poster
Poster是一个接口，里边只有一个enqueue方法。该接口实现类有三个，分别是HandlerPoster、BackgroundPoster和AsyncPoster。
在EventBus中，有三个字段分别代表了这三个Poster，分别是mainThreadPoster，backgroundPoster，asyncPoster，其初始化是在EventBus的构造函数中：
EventBus(EventBusBuilder builder) {
...
mainThreadSupport = builder.getMainThreadSupport();
mainThreadPoster = mainThreadSupport != null ? mainThreadSupport.createPoster(this) : null;
backgroundPoster = new BackgroundPoster(this);
asyncPoster = new AsyncPoster(this);
...
}
其中backgroundPoster和asyncPoster的生成都很简单，而mainThreadPoster相对复杂一点，他是通过mainThreadSupport.createPoster(this)生成的。
接下来，就具体看一看各个Poster是如何实现的。
3.4.1 HandlerPoster
public class HandlerPoster extends Handler implements Poster {
// 事件队列，缓存接收到的事件，见3.3.4
private final PendingPostQueue queue;
private final int maxMillisInsideHandleMessage;
private final EventBus eventBus;
// 判断当前Handler是否是活动的
private boolean handlerActive;
protected HandlerPoster(EventBus eventBus, Looper looper, int maxMillisInsideHandleMessage) {
super(looper);
this.eventBus = eventBus;
this.maxMillisInsideHandleMessage = maxMillisInsideHandleMessage;
queue = new PendingPostQueue();
}
public void enqueue(Subscription subscription, Object event) { ... }
@Override
public void handleMessage(Message msg) { ... }
}
HandlerPoster继承了Handler并实现了Poster接口，实现了enqueue和handleMessage方法，代表事件处理函数运行在主线程上。
通过HandlerPoster的类声明，我们知道这里是使用Handler机制来实现的，因此只要在HandlerPoster的构造方法中传入主线程的Looper对象，就能实现该功能。通过查看EventBusBuilder和AndroidHandlerMainThreadSupport类中的相关方法，发现确实如此。
3.4.1.1 enqueue方法
public 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");
}
}
}
}
这里首先将事件放到事件队列中，然后判断是否是活动的。如果是活动的，说明handleMessage方法正在循环从事件队列中取出事件并处理，所以不必再调用sendMessage方法，用于提高效率。
3.4.1.2 handleMessage方法
public void handleMessage(Message msg) {
boolean rescheduled = false;
try {
long started = SystemClock.uptimeMillis();
// 循环从事件队列中取出事件
while (true) {
PendingPost pendingPost = queue.poll();
if (pendingPost == null) {
synchronized (this) {
// 再次检查是否有事件，如果没有，将handlerActive置为false，并退出循环。
pendingPost = queue.poll();
if (pendingPost == null) {
handlerActive = false;
return;
}
}
}
// 调用invokeSubscriber方法真正执行事件处理函数
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;
}
}
3.4.2 BackgroundPoster
BackgroundPoster实现了Runnable和Poster接口，使用线程池实现后台执行的功能。
final class BackgroundPoster implements Runnable, Poster {
private final PendingPostQueue queue;
private final EventBus eventBus;
// 同HandlerPoster中的handlerActive字段作用一样；但由于run方法有可能运行在不同的线程中，所以加上了volatile修饰
private volatile boolean executorRunning;
BackgroundPoster(EventBus eventBus) {
this.eventBus = eventBus;
queue = new PendingPostQueue();
}
public void enqueue(Subscription subscription, Object event) { ... }
@Override
public void run() { ... }
}
3.4.2.1 enqueue方法
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);
}
}
}
这里同HandlerPoster一样，只不过使用的是线程池，而不是Handler。线程池的初始化是在EventBusBuilder中：
// -----EventBusBuilder.java
private final static ExecutorService DEFAULT_EXECUTOR_SERVICE = Executors.newCachedThreadPool();
ExecutorService executorService = DEFAULT_EXECUTOR_SERVICE;
3.4.2.2 run方法
public void run() {
try {
try {
// 循环取出事件
while (true) {
PendingPost pendingPost = queue.poll(1000);
if (pendingPost == null) {
synchronized (this) {
// 再次检查，没有事件则推出
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;
}
}
3.4.3 AsyncPoster
AsyncPoster同BackgroundPoster实现基本一样，只不过AsyncPoster每次只处理一个事件，并不会在处理过程将最近投递的事件一并处理。
3.4.4 PendingPostQueue
三个Poster中均有一个事件队列用来缓存接收到的事件，但其中又有一些不同的地方。
在向HandlerPoster和BackgroundPoster投递事件的时候，如果当前Poster正在处理事件，则Poster的enqueue方法将事件放到事件队列中后就直接返回，因为在handleMesage和run方法中都会循环从事件队列中取出事件处理，直到事件队列为空。这样提高了事件处理的速度，并节约了不必要的线程切换消耗。而AsyncPoster中的事件队列就并没有该效果。
事件队列的代码如下，提供了三个同步方法用来实现事件的入队和出队。
final class PendingPostQueue {
private PendingPost head;
private PendingPost tail;
synchronized void enqueue(PendingPost pendingPost) {
if (pendingPost == null) {
throw new NullPointerException("null cannot be enqueued");
}
if (tail != null) {
tail.next = pendingPost;
tail = pendingPost;
} else if (head == null) {
head = tail = pendingPost;
} else {
throw new IllegalStateException("Head present, but no tail");
}
notifyAll();
}
synchronized PendingPost poll() {
PendingPost pendingPost = head;
if (head != null) {
head = head.next;
if (head == null) {
tail = null;
}
}
return pendingPost;
}
synchronized PendingPost poll(int maxMillisToWait) throws InterruptedException {
if (head == null) {
wait(maxMillisToWait);
}
return poll();
}
}
4. EventBus总结
至此，EventBus所有源码已经分析结束。从代码中明白了EventBus的整体流程，并且通过分析不同的Poster，从中了解到EventBus对不同的ThreadMode是如何实现的。
总体来说，EventBus的源码还是比较简单的，流程也比较清晰，了解其实现后，在今后的使用中才能更加得心应手。
