EventBus原理源码分析和使用

前段时间被别人问到关于EventBus的原理，但我确实使用过，用起来也方便简单，一个注册，一个Post就能通知到所有的订阅者Subcriber，其实明明是知道一点点原理的，但是当时就是支支吾吾没有说，太low了，回来大概看了一眼EventBus的源码及实现原谅，现在想把看原代码的一些心得进行记录。OK，我们从Github上面了解一下官方如何介绍这个EventBus吧。


翻译:EventBus是一个事件发布/订阅总线，有效适用于Android系统平台。
EventBus...
.组件之间的通信更加简单
。针对在事件的发送者和订阅者之间进行解耦
。非常好的运用在Activitys、Fragments和后台线程
。避开了联系紧密易出错的依赖关系和容易出错生命周期
.使你的代码更加简洁
.快
.瘦(小于50K的jar包)
.有100,00,000+的app使用了EventBus

简单翻译就是这样一个意思，翻译不好请多担待，但是尽管翻译很差，但是大体的原理描述和工作是体现出来了。我是直接从Github上下载的最新的源代码进行研究的，在这里我想提出一个注意的地方，之前的旧一点的版本3.0之前的版本，订阅者的事件通知的方法都是通过开发者遵守命名约定，这样没有安全性，容易出错，很不方便开发，但是后来3.0开始使用注解的方式对事件的方法的声明。如下是之前的版本使用的命名约定的方式。
1、onEvent
2、onEventMainThread
3、onEventBackgroundThread
4、onEventAsync
现在最新版本订阅者的事件方法名称可以随意声明，只要在方法的上简单的加上一些相关的注解就可以了，而且注解是必须加上的，否则会抛出Runtime异常。OK，看看我们现在的做法:

</pre><pre code_snippet_id="1679566" snippet_file_name="blog_20160511_1_5619972" name="code" class="java">import org.greenrobot.eventbus.EventBus;
public class MainActivity extends Activity implements OnClickListener {
private Button mButton;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main_layout);
final Intent  intent= new Intent(this,EventBusTestService.class);
startService(intent);
EventBus.getDefault().register(this);
mButton = (Button) findViewById(R.id.button1);
mButton.setOnClickListener(this);
}

@Subscribe(threadMode=ThreadMode.ASYNC)
public void onEventReceive(EventBusMsg msg){
Log.d("ZHG-EventBusTest","MainActivity.onEventReceive , msg = "+msg.msg +" , MainThreadID = "+this.getMainLooper().getThread().getId()+" , currentTreadID = "+Thread.currentThread().getId());
}

@Override
public void onClick(View view) {
switch (view.getId() ) {
case R.id.button1:
EventBus.getDefault().post(new EventBusMsg("Test Message!!!!"));
break;
default:
break;
}
}

@Override
protected void onDestroy() {
super.onDestroy();
EventBus.getDefault().unregister(this);
}
}

package com.example.eventbustest;
import org.greenrobot.eventbus.EventBus;
public class EventBusTestService extends Service {
@Override
public IBinder onBind(Intent arg0) {
return null;
}

@Override
public void onCreate() {
super.onCreate();
EventBus.getDefault().register(this);
}

@Override
public void onDestroy() {
super.onDestroy();
EventBus.getDefault().unregister(this);
}

@Subscribe(threadMode=ThreadMode.BACKGROUND)
public void onEventBusMsgReceive(EventBusMsg msg){
Log.d("ZHG-EventBusTest","EventBusTestService.onEventBusMsgReceive , msg = "+msg.msg +" , MainThreadID = "+this.getMainLooper().getThread().getId()+" , currentTreadID = "+Thread.currentThread().getId());
}
}

从上面的示例代码就能看出，最新的版本再也不用那么麻烦的去记住什么约定的方法怎么写，不用再去背了，现在只要自己命名成自己喜欢的方法名，然后简单的加上注解就行，而且还可以设置线程模式，比如是是否在主线程、子线程、是否异步等。

OK，上面是针对使用上的一些变化进行一个温馨提示，接下来直接奔入主题，看源代码把。

1. EventBus.getDefault();开始
入口EventBus.getDefault();开始，这里我还是很喜欢这样的静态单例对象获取方法名，我本人也很喜欢使用单例的时候，取名getDefault()。

/** 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;
}

很简单，就是一个单例设计代码，看看构造方法。

/**
* Creates a new EventBus instance; each instance is a separate scope in which events are delivered. To use a
* central bus, consider {@link #getDefault()}.
*/
public EventBus() {
this(DEFAULT_BUILDER);
}

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;
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;
}

构造方法中创建了几个容器，用来装各种订阅者信息的，很关键的几个成员我们需要注意，mainThreadPoster 、backgroundPoster 、asyncPoster ，这个几个是后来post消息的时候，用的到的，就是利用他们将消息在不同的线程发送出去，达到在不同线程中执行的效果。
mainThreadPoster:很显然是一个自定义扩展后的Handler，在构造的时候传入的是主线的Looper，所以它是一个主线程的对应的Handler。
这里之间先看看这个Handler的代码吧：

* Copyright (C) 2012-2016 Markus Junginger, greenrobot (http://greenrobot.org)
package org.greenrobot.eventbus;

import android.os.Handler;

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;
}
}
}

没错，就是传入一个MainThread的Looper，创建了一个主线程的Handler，毋庸置疑，通过他发送的事件消息，都是在主线中执行的。

backgroundPoster : 那这个是什么呢，我们来看看代码。

* Copyright (C) 2012-2016 Markus Junginger, greenrobot (http://greenrobot.org)
package org.greenrobot.eventbus;

import android.util.Log;

/**
* Posts events in background.
*
* @author Markus
*/
final class BackgroundPoster implements Runnable {

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) {
Log.w("Event", Thread.currentThread().getName() + " was interruppted", e);
}
} finally {
executorRunning = false;
}
}
}

很明显他是一个实现了Runnable 的对象，所以它的载体肯定是一个子线程，是给某子线程执行具体任务的。

asyncPoster :再来看看这个，这个听名字就感觉已经知晓大部分信息了，异步Poster，可定也是在单独线程中post任务的。

* Copyright (C) 2012-2016 Markus Junginger, greenrobot (http://greenrobot.org)
package org.greenrobot.eventbus;

/**
* 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);
}
}

所以这里就不用多说了，也是一个实现了Runnable 的对象，一定也是被子线程执行的具体任务。

所以最后我们都能看到上面三段代码两个共同的两行代码:
eventBus.invokeSubscriber(pendingPost); 这行代码其实就是在使用反射调用订阅的者的事件方法。

eventBus.getExecutorService().execute(this); 这行代码很明显就是把时间提交给一个空闲的线程去执行。

当然HandlerPoster 就除外了，当然他是使用sendMessage的方式去去执行一个具体的事件，其实对应的也是 eventBus.getExecutorService().execute(this);这行代码。

OK，这里我们就浅层次的分析到这里，我们回到主线，继续。

2.register(Object subcriber)注册订阅者

我们通过EventBus的getDefualt()方法获取了一个EventBus的对象，然后就可以通过他来注册地订阅者了，接下来就看看EventBus的register(Object
subcriber)方法是如果实现的呢？

/**
* 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();
List<SubscriberMethod> subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);
synchronized (this) {
for (SubscriberMethod subscriberMethod : subscriberMethods) {
subscribe(subscriber, subscriberMethod);
}
}
}

OK，从上面的代码中，我们可以看到调用了subscriberMethodFinder对象的findSubscriberMethods(subscriberClass);方法，subscriberMethodFinder这个对象呢，我们其实都不用太关心，可以把他当作一个管理获取、查找、订阅者和订阅者Method的对象，然后通过它我们就能拿到一个List集合，这个集合存储的都是SubscriberMehtod对象，这里有必要去追求一下SubscriberMehtod是个什么东西呢，我们来看看吧:

* Copyright (C) 2012-2016 Markus Junginger, greenrobot (http://greenrobot.org)
package org.greenrobot.eventbus;

import java.lang.reflect.Method;

/** Used internally by EventBus and generated subscriber indexes. */
public class SubscriberMethod {
final Method method;
final ThreadMode threadMode;
final Class<?> eventType;
final int priority;
final boolean sticky;
/** Used for efficient comparison */
String methodString;

public SubscriberMethod(Method method, Class<?> eventType, ThreadMode threadMode, int priority, boolean sticky) {
this.method = method;
this.threadMode = threadMode;
this.eventType = eventType;
this.priority = priority;
this.sticky = sticky;
}

@Override
public boolean equals(Object other) {
if (other == this) {
return true;
} else if (other instanceof SubscriberMethod) {
checkMethodString();
SubscriberMethod otherSubscriberMethod = (SubscriberMethod)other;
otherSubscriberMethod.checkMethodString();
return methodString.equals(otherSubscriberMethod.methodString);
} else {
return false;
}
}

private synchronized void checkMethodString() {
if (methodString == null) {
// Method.toString has more overhead, just take relevant parts of the method
StringBuilder builder = new StringBuilder(64);
builder.append(method.getDeclaringClass().getName());
builder.append('#').append(method.getName());
builder.append('(').append(eventType.getName());
methodString = builder.toString();
}
}

@Override
public int hashCode() {
return method.hashCode();
}
}

很明显从这个SubscriberMethod 类的成员变量就能看出来，这是一个封装了一个关于Method的信息的对象，这些信息包括 final Method method(反射方法对象)对象、 final ThreadMode threadMode(线程模式)对象、final Class<?> eventType(事件类型，方法中的参数)对象、final int priority(权限)
标记、 final boolean sticky(是否sticky类型)标记、 String methodString(方法描述字串) 用来提高两个SubscriberMethod对象比较效率和准确性的。
所以这类就这么简单，就是封装了一个Mehtod的全部信息的。

接下来代码主线往下走。
我们来看一下findSubscriberMethods方法，是如何获取到订阅者的所有方法信息的，直接看方法。

List<SubscriberMethod> findSubscriberMethods(Class<?> subscriberClass) {
List<SubscriberMethod> subscriberMethods = METHOD_CACHE.get(subscriberClass);
if (subscriberMethods != null) {
return subscriberMethods;
}
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 {
METHOD_CACHE.put(subscriberClass, subscriberMethods);
return subscriberMethods;
}
}

从上面的代码可以看的出，一开始METHOD_CACHE这个集合是空的，获取的时候为空，逻辑会往下走，ignoreGeneratedIndex经过打印默认初始是为false的，所以下一步会走subscriberMethods = findUsingInfo(subscriberClass);
OK，直接来看findUsingInfo(subscriberClass)；方法。

private List<SubscriberMethod> findUsingInfo(Class<?> subscriberClass) {
FindState findState = prepareFindState();
findState.initForSubscriber(subscriberClass);
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);
}
}
} else {
findUsingReflectionInSingleClass(findState);
}
findState.moveToSuperclass();
}
return getMethodsAndRelease(findState);
}

findState.subscriberInfo = getSubscriberInfo(findState);根据打印，获取到的为null，

所以会走 findUsingReflectionInSingleClass(findState);我们也来看看这个方法的实现。

private void findUsingReflectionInSingleClass(FindState findState) {
Method[] methods;
try {
// This is faster than getMethods, especially when subscribers are fat classes like Activities
methods = findState.clazz.getDeclaredMethods();
} catch (Throwable th) {
methods = findState.clazz.getMethods();
findState.skipSuperClasses = true;
}
for (Method method : methods) {
int modifiers = method.getModifiers();
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];
if (findState.checkAdd(method, eventType)) {
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");
}
}
}

所以通过上面的代码，很明显就可以看出，是通过反射拿到每一个方法的修饰符信息，注解信息，参数信息，从上面的代码很明显就知道，我们的订阅方法必须有且只有一个参数，否则会抛出异常的，而且订阅方法必须是public修饰的，而且不是静态、不是抽象方法，否者也会抛出异常的，最后将合法的订阅方法都存到了一个findState.subscriberMethods集合中了，最后在findUsingReflectionInSingleClass(findState);的调用方发处调用了
return getMethodsAndRelease(findState);返回了出去了一个List<SubscriberMethod>集合，这里需要稍微提醒一个地方就是，我们应该都发现了findUsingInfo(Class<?> subscriberClass)
方法中的倒数第四行findState.moveToSuperclass(); 看看这个方法吧.

void moveToSuperclass() {
if (skipSuperClasses) {
clazz = null;
} else {
clazz = clazz.getSuperclass();
String clazzName = clazz.getName();
/** Skip system classes, this just degrades performance. */
if (clazzName.startsWith("java.") || clazzName.startsWith("javax.") || clazzName.startsWith("android.")) {
clazz = null;
}
}
}

这个方法主要是获取当前Class对象的父类(有可能是抽象类或者接口)，这样在findUsingInfo(Class<?> subscriberClass) 方法while中循环的获取到每一级Class对象中所有方法信息。

OK，findSubscriberMethods(...)方法就分析到这里，主线接着往下走，回到register方法中，往下看。

然后我们能看到一个for循环的遍历。

synchronized (this) {
for (SubscriberMethod subscriberMethod : subscriberMethods) {
subscribe(subscriber, subscriberMethod);
}
}

遍历每一个SubscriberMethod对象，遍历到每一个SubscriberMethod对象之后，调用EventBus的 subscribe(subscriber, subscriberMethod);方法，那我们就直接来看这个方法。

// 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;
}
}

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();
if (eventType.isAssignableFrom(candidateEventType)) {
Object stickyEvent = entry.getValue();
checkPostStickyEventToSubscription(newSubscription, stickyEvent);
}
}
} else {
Object stickyEvent = stickyEvents.get(eventType);
checkPostStickyEventToSubscription(newSubscription, stickyEvent);
}
}
}

一开始就取出了eventType，然后就创建了一个Subscription对象，这里又需要解释一下这个对象是个什么玩意了，直接贴代码吧。

* Copyright (C) 2012-2016 Markus Junginger, greenrobot (http://greenrobot.org)
package org.greenrobot.eventbus;

final class Subscription {
final Object subscriber;
final SubscriberMethod subscriberMethod;
/**
* Becomes false as soon as {@link EventBus#unregister(Object)} is called, which is checked by queued event delivery
* {@link EventBus#invokeSubscriber(PendingPost)} to prevent race conditions.
*/
volatile boolean active;

Subscription(Object subscriber, SubscriberMethod subscriberMethod) {
this.subscriber = subscriber;
this.subscriberMethod = subscriberMethod;
active = true;
}

@Override
public boolean equals(Object other) {
if (other instanceof Subscription) {
Subscription otherSubscription = (Subscription) other;
return subscriber == otherSubscription.subscriber
&& subscriberMethod.equals(otherSubscription.subscriberMethod);
} else {
return false;
}
}

@Override
public int hashCode() {
return subscriber.hashCode() + subscriberMethod.methodString.hashCode();
}
}

其实就是很简单的一个对象，我们可以看做一个简单的java bean就好了，他的功能就是封装了一个订阅者实体对象( final Object subscriber;)和上面我们解释过的，一个Mehtod信息的封装类(final SubscriberMethod subscriberMethod;)。

继续回到主线，我们可以看到，会把EventType和Subscriptions关联起来，很好理解，可以想象的到，我们Post一个事件的时候，一般会带一个事件类型，也就是post方法中的参数。
而一个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);
}
}

然后把一个个的新new出来的Subscription添加了subscriptions中，而subscriptions又和evetType关联起来了。添加新new出来的Subscription的时候，它会根据事件方法当时声明的时候，设置的priority注解信息，当priority的放在List的队列前面。

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;
}
}

再往下走，就是用实体对象和EventType关联了，这个也不难理解，我们可以理解为，一个实体对象可以写很多个订阅方法，但是没一个订阅方法可能会是不同的EventType(订阅方法的参数类型)，所以最后把eventType添加到了subscribedEvents之中。

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

最后一部分的代码是处理Sticky事件的逻辑，我们知道EventBus是可以调用成员方法
来postSticky(Object event)方法来提交一个事件。主要判断subscriberMethod的sticky是否为true，如果是，就从stickyEvents集合中获取所有相同事件类型的且设置了sticky属性的订阅者和订阅方法，然后就调用checkPostStickyEventToSubscription(newSubscription, stickyEvent);方法将事件发送出去了。

OK，到这里基本上register模块都解释的差不多了，上面我们也看到，各种事件对象、方法对象、和订阅者对象都已经封存起来，可以等待post事件的时候，将事件发送出去。
3. post(Object event) 发布订阅事件

Ok我们继续往下分析关于事件post的时候的实现原理。
我们知道我们在拿到EventBus的实例单例对象的时候，可以简单的就调用的他的post刚发，将一个特定的订阅事件类型发送出去，订阅者的订阅方法就能被回调了，我们来直接看这个方法吧。

/** Posts the given event to the event bus. */
public void post(Object event) {
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;
}
}
}

首先从currentPostingThreadState(LocalThread)中获取一个与当前线程关联的PostingThreadState对象，这个对象很简单，其实就是一个记录一个线程事件post状态的实体，可以稍微看看他的代码。

/** For ThreadLocal, much faster to set (and get multiple values). */
final static class PostingThreadState {
final List<Object> eventQueue = new ArrayList<Object>();
boolean isPosting;
boolean isMainThread;
Subscription subscription;
Object event;
boolean canceled;
}

没错就是这么简单，其成员也很好理解，eventQueue 很明显就是一个事件队列，isPosting 这个boolean类型的标记只要就是记录当先线程的事件发布状态，isMainThread主要就是标记当前线程是否为主线程，event事件类型、canceled是否取消post。

首先判断状态，假如下载正在post事件的时候，就不在接受post其他事件了，我们直接分析if语句块里面的代码吧，如果事件队列为空的话，就结束post过程，方法执行结束。
否则进入postSingleEvent(eventQueue.remove(0), postingState);方法中，然后每次都是获取事件队列中的栈顶的一个事件，注意是使用的remove(0)的方式来获取，直接来看postSingleEvent(Object event, PostingThreadState postingState)方法吧。

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) {
Log.d(TAG, "No subscribers registered for event " + eventClass);
}
if (sendNoSubscriberEvent && eventClass != NoSubscriberEvent.class &&
eventClass != SubscriberExceptionEvent.class) {
post(new NoSubscriberEvent(this, event));
}
}
}

首先我们知道eventInheritance的值是为true的，所以会先调用llookupAllEventTypes(eventClass)获取eventClass所有父类的后者接口类型的class对象，存到eventTypes
集合中，这里就不贴出lookupAllEventTypes(eventClass)的代码实现了，因为他的代码很简单，主要就是想上获取父类或者接口类型的class对象，因为比如父类或者接口为Car，BMW extends Car，这些都会被获取出来，记住是eventClass的父类和接口的calss对象哦，然后挨个遍历evnetClass对象。

for (int h = 0; h < countTypes; h++) {
Class<?> clazz = eventTypes.get(h);
subscriptionFound |= postSingleEventForEventType(event, postingState, clazz);
}

然后调用了postSingleEventForEventType(event, postingState, clazz);方法，我们直接看这个方法。

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;
}

OK，我们看到，从subscriptionsByEventType中取出一个subscriptions 对象，我们应该还有印象，前面我们讲过，说事件类型和事件订阅者关联起来了，一个订阅者可以实现多个订阅方法，接收不同事件类型，所以事件类型和订阅者关联起来， 将所有订阅者保存成集合，和事件类型关联了，Ok遍历subscriptions ，然后调用postToSubscription(subscription, event, postingState.isMainThread);方法去post事件给订阅者。我们直接看这个方法。

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);
}
}

所以上面的代码已经很明显了，就是根据ThreadMode来在不同的线程中发布事件，第一种 case POSTING:是默认方式下的，表示在当前线程中执行，也就是在事件post所在线程中执行，我们看到它是直接调用 invokeSubscriber(subscription, event)方法去执行了，看看这个方法吧。

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);
}
}

我们看到，代码很简单，就一句话，利用发射的方式去执行了，其他的都是异常捕获。

接着看第二种 case MAIN:很明显是在主线程中执行的，我们看这个case下的实现方式。

if (isMainThread) {
invokeSubscriber(subscription, event);
} else {
mainThreadPoster.enqueue(subscription, event);
}

很好理解，如果当前已经是在主线程中，就直接跟第一种方式一样，直接在当前线程中执行就OK了，如果当前不是主线程，那么只能通过主线程的Handler来发送handler事件消息到主线程去执行了，使用mainThreadPoster将事件加入执行队列，mainThreadPoster我们在一开始的时候我们讲过，他们的实现也很简单，这个具体怎么发送和执行可以去看看，但是他们最后都是调用EventBus的invokeSubscriber(subscription, event);方法来执行的。

第三种case BACKGROUND: 很明显，就是在后台子线程中执行了，看看这个case下的代码实现吧。

if (isMainThread) {
backgroundPoster.enqueue(subscription, event);
} else {
invokeSubscriber(subscription, event);
}

也很简单，直接判断当前是否为主线程，如果主线程的话，就直接使用backgroundPoster来将事件加入执行队列，

backgroundPoster我们在前面做过铺垫，他就是一个Runnable的实现体，接着调用了它自己的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);
}
}
}

最后线程执行，就调用了

backgroundPoster的run方法。

@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) {
Log.w("Event", Thread.currentThread().getName() + " was interruppted", e);
}
} finally {
executorRunning = false;
}
}

他最后是通过queue.poll(1000);取出一个事件，将事件交个了EventBus中线程池来执行，从而达到了

backgroundPost的效果，也就是子线程执行的效果。

但是我们这里应该需要注意一个地方，那就是

queue.enqueue(pendingPost);这个将事件的入队操作，这里还是有必要看一下queue这个队列是个什么样的实现方式。

final class BackgroundPoster implements Runnable {

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);
}
}
}

我们看到queue 是一个PendingPostQueue类型的实体成员变量。我们直接贴上这个类的代码来看看。

* Copyright (C) 2012-2016 Markus Junginger, greenrobot (http://greenrobot.org)

package org.greenrobot.eventbus;

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();
}

}

从上面的代码我们可以看出，poll和enqueue 都加上synchronized ，他就是模拟了一个事件队列，enqueue就是将事件入队的动作，当然还模拟了一个事件的队列的队头队尾和next，首先上面代码一开始head为和tail应该都为null，所以会执行如下代码。
head = tail = pendingPost;
将当前队列的头尾都设置为pendingPost(当前事件)，然后调用notifyAll()方法，通知线程去执行任务，就是把任务交给EventBus中声明的线程池来执行，最后调用到了run方法了，在run方法中调用了 queue.poll(1000);来一个事件，看看poll(int maxMillisToWait)方法吧。

synchronized PendingPost poll(int maxMillisToWait) throws InterruptedException {
if (head == null) {
wait(maxMillisToWait);
}
return poll();
}

也是很简单啊，直接判断队头是否为空，如果为空就让线程先等1000毫秒，所以最后只有在enqueue被调用，加入新的事件后，notifyAll唤醒线程去调用无参数的重载方法来取出事件返回出去。

synchronized PendingPost poll() {
PendingPost pendingPost = head;
if (head != null) {
head = head.next;
if (head == null) {
tail = null;
}
}
return pendingPost;
}

方法也很简单，首先直接把head赋值给一个新的 pendingPost变量，再判断如果head不为空，直接把下一个next事件复制给head，典型的先进先出队列，然后返回pendingPost。

其实到这里其实也有两个很重要的知识点，队列概念的巧妙是使用，先进先出方式的使用，还有一个是生产者和消费者的概念。

回归主线，判断如果不是主线程，就刚好，直接执行事件就可以了，看最后一种

case ASYNC：

这种其实跟 BACKGROUND一样的执行方式，因为asyncPoster本身也是一个Runnable的实现体，最后也调用了enqueue方法把任务交给了EventBus中的线程池来执行，具体代码基本和BACKGROUND的分析一样的。但是这个和BACKGROUND是有区别的，它是任何时候都要在子线程中执行的.

整个EventBus的原理基本上就分析到这里了，转载请注明出处，欢迎大家吐槽。