深入分析了 Android EventBus 框架的源码实现。文章首先介绍了 EventBus 的基本用法及与广播的区别，阐述了其基于观察者模式的原理。随后详细剖析了 register、post、unregister 三大核心方法的源码流程，包括单例模式、订阅方法查找、线程模式分发机制以及粘性事件处理。重点解释了 CopyOnWriteArrayList 在并发场景下的应用、ThreadLocal 在线程隔离中的作用以及对象池优化策略。最后总结了 EventBus 的最佳实践，强调了内存泄漏防护和线程模式选择的重要性，为开发者理解和使用 EventBus 提供了全面的参考。
首先，定义要传递的事件实体类。
public class CollectEvent {
private String message;
public CollectEvent(String message) {
this.message = message;
}
public String getMessage() {
return message;
}
}
声明并注解你的订阅方法。
@Subscribe(threadMode = ThreadMode.MAIN)
public void onMessageEvent(CollectEvent event) {
Log.d("EventBus", "Received: " + event.getMessage());
}
在订阅者所在的类中（如 Activity），注册和解注册你的订阅者。
@Override
protected void onStart() {
super.onStart();
EventBus.getDefault().register(this);
}
@Override
protected void onStop() {
super.onStop();
EventBus.getDefault().unregister(this);
}
EventBus.getDefault().post(new CollectEvent("Hello World"));
在正式讲解之前，需要对一些基础性的概念进行详细的讲解。众所周知，EventBus 出现之前，开发者一般使用 Android 四大组件中的广播进行组件间的消息传递。那么为什么要使用事件总线机制来替代广播呢？主要是因为：
事件总线机制通过记录对象、使用观察者模式来通知对象各种事件。（当然，你也可以发送基本数据类型如 int，String 等作为一个事件）。
对于 EventBus 而言，它的优缺点总结如下：
EventBus 是基于观察者模式扩展而来的。观察者模式又可称为发布 - 订阅模式，它定义了对象间的一种 1 对多的依赖关系，每当这个对象的状态改变时，其它的对象都会接收到通知并被自动更新。
观察者模式有以下角色：
EventBus 的观察者模式和一般的观察者模式不同，它使用了扩展的观察者模式对事件进行订阅和分发。这里的扩展是指使用了 EventBus 来作为中介者，抽离了许多职责。
每次我们在 register 之后，都必须进行一次 unregister，这是因为 register 是强引用，它会让对象无法得到内存回收，导致内存泄露。所以必须在 unregister 方法中释放对象所占的内存。
有些同学可能之前使用的是 EventBus 2.x 的版本，那么它与 EventBus 3.x 的版本有哪些区别呢？
除了 EventBus，其实现在比较流行的事件总线还有 RxBus。那么，它与 EventBus 相比又如何呢？
在新项目选型时，如果项目中使用了 RxJava，则使用 RxBus，否则使用 EventBus 3.x。
接下来将按以下顺序来进行 EventBus 的源码分析：
EventBus.getDefault().register(this)EventBus.getDefault().post(new CollectEvent())EventBus.getDefault().unregister(this)首先，我们从获取 EventBus 实例的方法 getDefault() 开始分析：
public static EventBus getDefault() {
if (defaultInstance == null) {
synchronized (EventBus.class) {
if (defaultInstance == null) {
defaultInstance = new EventBus();
}
}
}
return defaultInstance;
}
在 getDefault() 中使用了双重校验并加锁的单例模式来创建 EventBus 实例。
接着，我们看到 EventBus 的默认构造方法中做了什么：
private static final EventBusBuilder DEFAULT_BUILDER = new EventBusBuilder();
public EventBus() {
this(DEFAULT_BUILDER);
}
在 EventBus 的默认构造方法中又调用了它的另一个有参构造方法，将一个类型为 EventBusBuilder 的 DEFAULT_BUILDER 对象传递进去了。这里的 EventBusBuilder 很明显是一个 EventBus 的建造器，以便于 EventBus 能够添加自定义的参数和安装一个自定义的默认 EventBus 实例。
我们再看一下 EventBus 的这个有参构造方法：
private final Map<Class<?>, CopyOnWriteArrayList<Subscription>> subscriptionsByEventType;
private final Map<Object, List<Class<?>>> typesBySubscriber;
private final Map<Class<?>, Object> stickyEvents;
EventBus(EventBusBuilder builder) {
// 1
subscriptionsByEventType = new HashMap<>();
// 2
typesBySubscriber = new HashMap<>();
// 3
stickyEvents = new ConcurrentHashMap<>();
// 4
mainThreadSupport = builder.getMainThreadSupport();
mainThreadPoster = mainThreadSupport != null ? mainThreadSupport.createPoster(this) : null;
backgroundPoster = new BackgroundPoster(this);
asyncPoster = new AsyncPoster(this);
// 5
subscriberMethodFinder = new SubscriberMethodFinder(builder.subscriberInfoIndexes,
builder.strictMethodVerification, builder.ignoreGeneratedIndex);
// 6
executorService = builder.executorService;
}
subscriptionsByEventType 对象，key 为 Event 类型，value 为 Subscription 链表。Subscription 保存了 subscriber（注册的对象）和 subscriberMethod（被@Subscribe 注解的方法）。typesBySubscriber 对象，key 为 subscriber 对象，value 为该对象中所有的 Event 类型链表，用于判断某个对象是否注册过。stickyEvents 对象，专用于粘性事件处理，key 为事件的 Class 对象，value 为当前的事件。mainThreadPoster：主线程事件发送器。backgroundPoster：后台事件发送器，保证任一时间只且仅能有一个任务会被线程池执行。asyncPoster：异步运行的，可以同时接收多个任务。subscriberMethodFinder 对象，这是从 EventBus 中抽离出的订阅方法查询的一个对象。Executors.newCachedThreadPool() 方法创建。接着我们查看 EventBus 的 register() 方法：
public void register(Object subscriber) {
Class<?> subscriberClass = subscriber.getClass();
// 1
List<SubscriberMethod> subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);
synchronized (this) {
for (SubscriberMethod subscriberMethod : subscriberMethods) {
// 2
subscribe(subscriber, subscriberMethod);
}
}
}
在注释 1 处，根据当前注册类获取 subscriberMethods 这个订阅方法列表。在注释 2 处，使用了增强 for 循环令 subscriber 对象对 subscriberMethods 中每个 SubscriberMethod 进行订阅。
接着我们查看 SubscriberMethodFinder 的 findSubscriberMethods() 方法：
List<SubscriberMethod> findSubscriberMethods(Class<?> subscriberClass) {
// 1
List<SubscriberMethod> subscriberMethods = METHOD_CACHE.get(subscriberClass);
if (subscriberMethods != null) {
return subscriberMethods;
}
// 2
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;
}
}
注释 2 处，先详细说说这个 ignoreGeneratedIndex 字段，它用来判断是否使用生成的 APT 代码去优化寻找接收事件的过程。如果我们没有在项目中接入 EventBus 的 APT，那么可以将 ignoreGeneratedIndex 字段设为 false 以提高性能。这里 ignoreGeneratedIndex 默认为 false，所以会执行 findUsingInfo() 方法。
接着我们查看 SubscriberMethodFinder 的 findUsingInfo() 方法：
private List<SubscriberMethod> findUsingInfo(Class<?> subscriberClass) {
// 1
FindState findState = prepareFindState();
findState.initForSubscriber(subscriberClass);
// 2
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 {
// 3
findUsingReflectionInSingleClass(findState);
}
findState.moveToSuperclass();
}
// 4
return getMethodsAndRelease(findState);
}
在注释 1 处，调用了 prepareFindState() 方法创建了一个新的 FindState 类。它是 SubscriberMethodFinder 的内部类，主要做初始化、回收对象等工作。这里使用了对象池模式，先从 FIND_STATE_POOL 池中取出可用的 FindState，如果没有的话，则直接新建一个新的 FindState 对象。
在注释 3 处，如果找不到预生成的索引信息，则回退到反射查找。这个方法通过反射的方式获取订阅者类中的所有声明方法，然后在这些方法里面寻找以 @Subscribe 作为注解的方法进行处理。在经过一轮检查后，将方法名、threadMode、优先级、是否为 sticky 方法等信息封装到 SubscriberMethod 对象中，最后添加到 subscriberMethods 列表中。
最后，在 EventBus 的 register() 方法的最后会调用 subscribe 方法：
private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
Class<?> eventType = subscriberMethod.eventType;
Subscription newSubscription = new Subscription(subscriber, subscriberMethod);
// 1
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();
// 2
for (int i = 0; i <= size; i++) {
if (i == size || subscriberMethod.priority > subscriptions.get(i).subscriberMethod.priority) {
subscriptions.add(i, newSubscription);
break;
}
}
// 3
List<Class<?>> subscribedEvents = typesBySubscriber.get(subscriber);
if (subscribedEvents == null) {
subscribedEvents = new ArrayList<>();
typesBySubscriber.put(subscriber, subscribedEvents);
}
subscribedEvents.add(eventType);
// 4
if (subscriberMethod.sticky) {
if (eventInheritance) {
Set<Map.Entry<Class<?>, Object>> entries = stickyEvents.entrySet();
(Map.Entry<Class<?>, Object> entry : entries) {
Class<?> candidateEventType = entry.getKey();
(eventType.isAssignableFrom(candidateEventType)) {
entry.getValue();
checkPostStickyEventToSubscription(newSubscription, stickyEvent);
}
}
} {
stickyEvents.get(eventType);
checkPostStickyEventToSubscription(newSubscription, stickyEvent);
}
}
}
eventType 在 subscriptionsByEventType 去查找一个 CopyOnWriteArrayList，如果没有则创建一个新的。newSubscription 对象，按照优先级添加。优先级越高，会插到在当前 List 靠前面的位置。typesBySubscriber 进行添加，用于判断该 Subscriber 对象是否已被注册过。checkPostStickyEventToSubscription() 方法。public void post(Object event) {
// 1
PostingThreadState postingState = currentPostingThreadState.get();
List<Object> eventQueue = postingState.eventQueue;
eventQueue.add(event);
// 2
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;
}
}
}
注释 1 处，currentPostingThreadState 是一个 ThreadLocal 类型的对象，里面存储了 PostingThreadState。接着把传入的 event，保存到了当前线程中的一个变量 PostingThreadState 的 eventQueue 中。在注释 2 处，最后调用了 postSingleEvent() 方法。
private void postSingleEvent(Object event, PostingThreadState postingState) throws Error {
Class<?> eventClass = event.getClass();
boolean subscriptionFound = false;
// 1
if (eventInheritance) {
// 2
List<Class<?>> eventTypes = lookupAllEventTypes(eventClass);
int countTypes = eventTypes.size();
for (int h = 0; h < countTypes; h++) {
Class<?> clazz = eventTypes.get(h);
subscriptionFound |=
// 3
postSingleEventForEventType(event, postingState, clazz);
}
} else {
subscriptionFound = postSingleEventForEventType(event, postingState, eventClass);
}
if (!subscriptionFound) {
// 无订阅者时的处理
}
}
eventInheritance 标志位，默认为 true。如果设为 true，会在发射事件的时候判断是否需要发射父类事件，设为 false 能够提高一些性能。lookupAllEventTypes() 方法，取出 Event 及其父类和接口的 class 列表。postSingleEventForEventType() 方法。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;
}
这里直接根据 Event 类型从 subscriptionsByEventType 中取出对应的 subscriptions 对象，最后调用了 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 {
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);
}
}
从上面可以看出，这里通过 threadMode 来判断在哪个线程中去执行方法：
invokeSubscriber() 方法，内部直接采用反射调用。mainThreadPoster 的 enqueue() 方法，即把当前的方法加入到队列之中，然后通过 handler 去发送一个消息，在 handler 的 handleMessage 中去执行方法。backgroundPoster 的 enqueue() 方法将方法加入到后台的一个队列，最后通过线程池去执行。注意，backgroundPoster 在 Executor 的 execute() 方法上添加了 synchronized 关键字并设立了一个控制标记 flag，保证任一时间只且仅能有一个任务会被线程池执行。backgroundPoster 的保证任一时间只且仅能有一个任务会被线程池执行的特性，这里 asyncPoster 则是异步运行的，可以同时接收多个任务。public synchronized void unregister(Object subscriber) {
List<Class<?>> subscribedTypes = typesBySubscriber.get(subscriber);
if (subscribedTypes != null) {
for (Class<?> eventType : subscribedTypes) {
// 1
unsubscribeByEventType(subscriber, eventType);
}
// 2
typesBySubscriber.remove(subscriber);
}
}
unsubscribeByEventType() 方法中对 subscriptionsByEventType 移除了该 subscriber 的所有订阅信息。如果想要发射 sticky 事件需要通过 EventBus 的 postSticky() 方法，内部源码如下所示：
public void postSticky(Object event) {
synchronized (stickyEvents) {
// 1
stickyEvents.put(event.getClass(), event);
}
// 2
post(event);
}
在注释 1 处，先将该事件放入 stickyEvents 中，接着在注释 2 处使用 post() 发送事件。
在 register() 方法的最后部分，有关粘性事件的源码如下：
if (subscriberMethod.sticky) {
Object stickyEvent = stickyEvents.get(eventType);
if (stickyEvent != null) {
postToSubscription(newSubscription, stickyEvent, isMainThread());
}
}
可以看到，在这里会判断当前事件是否是 sticky 事件，如果是，则从 stickyEvents 中拿出该事件并执行 postToSubscription() 方法。
EventBus 最核心的风险在于内存泄漏。由于 register 是强引用，如果 Activity 或 Fragment 销毁时未调用 unregister，会导致持有该对象的 EventBus 实例无法被 GC 回收。因此，务必在 onDestroy 或 onStop 中取消注册。
粘性事件适合用于传递状态数据（如用户登录状态）。但要注意，粘性事件会一直保存在内存中，直到手动清除或应用重启。频繁发送粘性事件会增加内存负担。
EventBus 的源码在 Android 主流三方库源码分析系列中算是比较简单的了。但是，它其中的一些思想和设计是值得借鉴的。比如它使用 FindState 复用池来复用 FindState 对象，在各处使用了 synchronized 关键字进行代码块同步的一些优化操作。其中上面分析了这么多，EventBus 最核心的逻辑就是利用了 subscriptionsByEventType 这个重要的列表，将订阅对象，即接收事件的方法存储在这个列表，发布事件的时候在列表中查询出相对应的方法并执行。
通过合理使用 EventBus，可以显著降低组件间的耦合度，提升代码的可维护性。但在实际开发中，也需警惕其带来的潜在问题，如内存泄漏和调试困难。建议结合项目实际情况，选择合适的通信方案。
微信公众号「极客日志」，在微信中扫描左侧二维码关注。展示文案：极客日志 zeeklog
查找任何按下的键的javascript键代码、代码、位置和修饰符。 在线工具，Keycode 信息在线工具，online
JavaScript 字符串转义/反转义；Java 风格 \uXXXX（Native2Ascii）编码与解码。 在线工具，Escape 与 Native 编解码在线工具，online
使用 Prettier 在浏览器内格式化 JavaScript 或 HTML 片段。 在线工具，JavaScript / HTML 格式化在线工具，online
Terser 压缩、变量名混淆，或 javascript-obfuscator 高强度混淆（体积会增大）。 在线工具，JavaScript 压缩与混淆在线工具，online
将字符串编码和解码为其 Base64 格式表示形式即可。 在线工具，Base64 字符串编码/解码在线工具，online
将字符串、文件或图像转换为其 Base64 表示形式。 在线工具，Base64 文件转换器在线工具，online