1 EventBus 简介
- 简介
- 角色
- 关系图
- 四种线程模型
2.EventBus使用步骤
- 添加依赖
- 注册
- 解注册
- 创建消息类
- 发送消息
- 接收消息
- 粘性事件
- - 发送消息使用postStick()
  - 接受消息
3 EventBus做通信优点
4 源码
- getDefault()
- register()
- - findSubscriberMethods方法
  - findUsingReflection方法
  - findUsingReflectionInSingleClass方法
  - checkAdd方法、checkAddWithMethodSignature方法
  - moveToSuperclass 方法
  - findUsingInfo方法
- subscribe 方法订阅流程
- post方法
- - postSingleEvent、 postSingleEventForEventType、 postToSubscription
  - invokeSubscriber方法
  - postSticky方法
- unregister方法
- - unsubscribeByEventType方法
5 总结

1 EventBus 简介

简介

EventBus是一种用于Android的事件发布-订阅总线，由GreenRobot开发，它简化了应用程序内各个组件之间进行通信的复杂度，尤其是碎片之间进行通信的问题，可以避免由于使用广播通信而带来的诸多不便。这里的事件可以理解为消息，传统的事件传递方式包括：Intent、Handler、BroadCastReceiver、Interface 回调，相比之下 EventBus 的优点是代码简洁，使用简单，并将事件发布和订阅充分解耦。可简化 Activities, Fragments, Threads, Services 等组件间的消息传递，可替代 Intent、
Handler、BroadCast、接口等传统方案，更快，代码更小，50K 左右的 jar 包，代码更优雅，彻底解耦。
Github

角色

事件(Event)：又可称为消息，本文中统一用事件表示。其实就是一个对象，可以是任意类型。事件类型(EventType)指事件所属的Class。事件分为一般事件和 Sticky 事件，相对于一般事件，Sticky 事件不同之处在于，当事件发布后，再有订阅者开始订阅该类型事件，依然能收到该类型事件最近一个 Sticky 事件。
订阅者(Subscriber)：订阅某种事件类型的对象。当有发布者发布这类事件后，EventBus会执行订阅者的 onEvent 函数，这个函数叫事件响应函数。订阅者通过 register 接口订阅某个事件类型，unregister 接口退订。订阅者存在优先级，优先级高的订阅者可以取消事件继续向优先级低的订阅者分发，默认所有订阅者优先级都为 0。在EventBus 3.0之前我们必须定义以onEvent开头的那几个方法，分别是onEvent、onEventMainThread、onEventBackgroundThread和onEventAsync；而在3.0之后事件处理的方法名可以随意取，不过需要加上注解@subscribe，并且指定线程模型，默认是POSTING。

关系图

EventBus 、订阅者、发布者关系图
EventBus 负责存储订阅者、事件相关信息，订阅者和发布者都只和 EventBus 关联。
事件相应流程
订阅者首先调用 EventBus 的 register 接口订阅某种类型的事件，当发布者通过 post接口发布该类型的事件时，EventBus 执行调用者的事件响应函数

四种线程模型

POSTING：默认，表示事件处理函数的线程跟发布事件的线程在同一个线程。
MAIN：表示事件处理函数的线程在主线程(UI)线程，因此在这里不能进行耗时操作。
ASYNC：表示无论事件发布的线程是哪一个，事件处理函数始终会新建一个子线程运行，同样不能进行UI操作，可以异步并发处理。
BACKGROUND：表示事件处理函数的线程在后台线程，因此不能进行UI操作。如果发布事件的线程是主线程(UI线程)，那么事件处理函数将会开启一个后台线程，如果果发布事件的线程是在后台线程，那么事件处理函数就使用该线程，不能并发处理。

2.EventBus使用步骤

添加依赖

implementation("org.greenrobot:eventbus:3.3.1")

注册

通常注册、解注册、接收消息都在一起（同一个页面中），发送在另外的地方。
避免重复注册，重复注册可能导致存在多个此类对象可能导致重复多次的接收

        if (!EventBus.getDefault().isRegistered(this)) {
            EventBus.getDefault().register(this);
        }

解注册

在退出页面时解注册比如

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

创建消息类

比如消息类 Msg

public class Msg {
    private String msg;

    public Msg(String msg) {
        this.msg = msg;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }

    @Override
    public String toString() {
        return "Msg{" +
                "msg='" + msg + '\'' +
                '}';
    }
}

发送消息

  EventBus.getDefault().post(new Msg("EventBus  发送消息"));

接收消息

通常注册、解注册、接收消息都在一起，发送在另外的地方。

    @Subscribe(threadMode = ThreadMode.MAIN)
    public void onMessageEvent(Msg msg) {
        Log.i("TAG", "MainActivity 页面 msg:" + msg.getMsg().toString());
    }

粘性事件

指发送了该事件之后再订阅者依然能够接收到的事件。使用黏性事件的时候有两个地方需要做些修改。一个是订阅事件的地方，这里我们在先打开的Activity中注册监听黏性事件；另一个是接受接收事件的方法需要修改。

发送消息使用postStick()

EventBus.getDefault().postSticky(new Msg("EventBus  发送消息"));

接受消息

sticky是一个boolean型的参数，默认值是false，表示不启用sticky特性。

@Subscribe(threadMode = ThreadMode.MAIN, sticky = true)
public void onGetStickyEvent(Msg msg) {
        Log.i("TAG", "MainActivity 页面 粘性事件 msg:" + msg.getMsg().toString());
}

3 EventBus做通信优点

1.简化了组件间交流的方式
2.对事件通信双方进行解耦
3.可以灵活方便的指定工作线程，通过ThreadMode
4.速度快，性能好
5.库比较小，不占内存
6.使用这个库的app多，有权威性
7.功能多，使用方便

4 源码

getDefault()

    /** Convenience singleton for apps using a process-wide EventBus instance. */
    public static EventBus getDefault() {
        EventBus instance = defaultInstance;
        if (instance == null) {
            synchronized (EventBus.class) {
                instance = EventBus.defaultInstance;
                if (instance == null) {
                    instance = EventBus.defaultInstance = new EventBus();
                }
            }
        }
        return instance;
    }

EventBus 类采用了Double Check 的单例类。
接下类看下它的构造函数。它的无参构造函数调用的是EventBus（EventBusBuilder）的有参构造函数，传入的参数是DEFAULT_BUILDER，而 DEFAULT_BUILDER 则是一个调用了 EventBusBuilder默认构造器的对象。可以看出，这里用到了 Builder 模式来支持用EventBusBuilder 进行一些配置。

EventBus(EventBusBuilder builder)主要进行的是一些容器的初始化以及将一些配置参数从 Builder中取出。

    private static final EventBusBuilder DEFAULT_BUILDER = new EventBusBuilder();

    /**
     * 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) {
        logger = builder.getLogger();
        subscriptionsByEventType = new HashMap<>();
        typesBySubscriber = new HashMap<>();
        stickyEvents = new ConcurrentHashMap<>();
        mainThreadSupport = builder.getMainThreadSupport();
        mainThreadPoster = mainThreadSupport != null ? mainThreadSupport.createPoster(this) : null;
        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;
    }

register()

    /**
     * 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) {
        if (AndroidDependenciesDetector.isAndroidSDKAvailable() && !AndroidDependenciesDetector.areAndroidComponentsAvailable()) {
            // Crash if the user (developer) has not imported the Android compatibility library.
            throw new RuntimeException("It looks like you are using EventBus on Android, " +
                    "make sure to add the \"eventbus\" Android library to your dependencies.");
        }

        Class<?> subscriberClass = subscriber.getClass();
        List<SubscriberMethod> subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);
        synchronized (this) {
            for (SubscriberMethod subscriberMethod : subscriberMethods) {
                subscribe(subscriber, subscriberMethod);
            }
        }
    }

register 传入的 register 是一个 Object 类型(任意类型都可以通过EventBus的register)。首先是if判断，它获取到了 subscriber 的类型信息，然后将其传递给了 subscriberMethodFinder 的 findSubscriberMethods() 方法。通过名称可以很容易看出，SubscriberMethodFinder 类是一个专门用来搜索查询subscriber 中含有 @Subscribe 注解的方法的类。这里进行的操作就是将所有被 @Subscribe 标记的方法都加入到 List 中；加锁保证了线程安全。

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

ignoreGeneratedIndex 为true 时调用的是findUsingReflection(subscriberClass);通过反射来搜索方法；ignoreGeneratedIndex 为false 时，findUsingInfo(subscriberClass)进行搜索，

findUsingReflection方法

    private List<SubscriberMethod> findUsingReflection(Class<?> subscriberClass) {
        FindState findState = prepareFindState();
        findState.initForSubscriber(subscriberClass);
        while (findState.clazz != null) {
            findUsingReflectionInSingleClass(findState);
            findState.moveToSuperclass();
        }
        return getMethodsAndRelease(findState);
    }

搜索到的结果通过FindState 来存储。FindState是SubscriberMethodFinder的内部类。
在while 循环，它先执行了 findUsingReflectionInSingleClass 方法通过反射找到所有被 @Subscribe 标注的方法，再通过 moveToSuperclass 向这个类的父类进行搜索查询

findUsingReflectionInSingleClass方法

    
    private static final int MODIFIERS_IGNORE = Modifier.ABSTRACT | Modifier.STATIC | BRIDGE | SYNTHETIC;
    
    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) {
            // Workaround for java.lang.NoClassDefFoundError, see https://github.com/greenrobot/EventBus/issues/149
            try {
                methods = findState.clazz.getMethods();
            } catch (LinkageError error) { // super class of NoClassDefFoundError to be a bit more broad...
                String msg = "Could not inspect methods of " + findState.clazz.getName();
                if (ignoreGeneratedIndex) {
                    msg += ". Please consider using EventBus annotation processor to avoid reflection.";
                } else {
                    msg += ". Please make this class visible to EventBus annotation processor to avoid reflection.";
                }
                throw new EventBusException(msg, error);
            }
            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");
            }
        }
    }

getDeclaredMethods、getMethods都是用来获取Method列表。获取到Method列表后进行for循环校验(两次校验)，检验是否被Subscribe修饰的方法是否是public、non-static、non-abstract，non-protected；通过checkAdd进行校验。

checkAdd方法、checkAddWithMethodSignature方法

       boolean checkAdd(Method method, Class<?> eventType) {
            // 2 level check: 1st level with event type only (fast), 2nd level with complete signature when required.
            // Usually a subscriber doesn't have methods listening to the same event type.
            Object existing = anyMethodByEventType.put(eventType, method);
            if (existing == null) {
                return true;
            } else {
                if (existing instanceof Method) {
                    if (!checkAddWithMethodSignature((Method) existing, eventType)) {
                        // Paranoia check
                        throw new IllegalStateException();
                    }
                    // Put any non-Method object to "consume" the existing Method
                    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());

            String methodKey = methodKeyBuilder.toString();
            Class<?> methodClass = method.getDeclaringClass();
            Class<?> methodClassOld = subscriberClassByMethodKey.put(methodKey, methodClass);
            if (methodClassOld == null || methodClassOld.isAssignableFrom(methodClass)) {
                // Only add if not already found in a sub class
                return true;
            } else {
                // Revert the put, old class is further down the class hierarchy
                subscriberClassByMethodKey.put(methodKey, methodClassOld);
                return false;
            }
        }

moveToSuperclass 方法

该方法向其父类进行查询

    void moveToSuperclass() {
        if (skipSuperClasses) {
            clazz = null;
        } else {
            clazz = clazz.getSuperclass();
            String clazzName = clazz.getName();
            // Skip system classes, this degrades performance.
            // Also we might avoid some ClassNotFoundException (see FAQ for background).
            if (clazzName.startsWith("java.") || clazzName.startsWith("javax.") ||
                    clazzName.startsWith("android.") || clazzName.startsWith("androidx.")) {
                clazz = null;
            }
        }
    }

findUsingInfo方法

通过 getSubscriberInfo(findState)获取到了由 Builder 过程传入的SubscriberInfoIndex，从中获取需要的信息。当其值为 null 时，再使用反射的方式进行搜索查询

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

subscribe 方法订阅流程

    // 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);
       // 检查同样的方法是否已经被注册过，没有则将其放入 Map 中，否则抛出异常。
        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);
            }
        }
	
	//将其按照优先级放入以该 Event 为参数的方法列表中。
        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 为 key，以它内部所有被 @Subscribe 标记的方法的列表为 value 的 Map typesBySubscriber 中
        List<Class<?>> subscribedEvents = typesBySubscriber.get(subscriber);
        if (subscribedEvents == null) {
            subscribedEvents = new ArrayList<>();
            typesBySubscriber.put(subscriber, subscribedEvents);
        }
        subscribedEvents.add(eventType);

		//对stick事件的处理。主要逻辑是：首先判断了 Event 是否子 Event，若是一个子 Event 则找到其父 Event 作为参数 Event，否则将其作为参   数 Event，然后在判 null 的情况下调用 postToSubscription 方法来执行这个方法
        if (subscriberMethod.sticky) {
            if (eventInheritance) {
                // Existing sticky events of all subclasses of eventType have to be considered.
				// 必须考虑eventType的所有子类的现有粘性事件.
                // 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>).
                //（例如，存储超类的子类的附加映射：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);
            }
        }
    }

Subcription是一个将 Subcriber 及 SubcriberMethod 进行包装的类.

post方法

    /** Posts the given event to the event bus. */
    public void post(Object event) {
        PostingThreadState postingState = currentPostingThreadState.get();
        List<Object> eventQueue = postingState.eventQueue;
        // event 插入 eventQueue 中
        eventQueue.add(event);

        if (!postingState.isPosting) {//避免每次post方法都会去调用整个队列。
            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;
            }
        }
    }

首先获取 currentPostingThreadState 对象，它的类型是PostingThreadState，这个类的主要用途是记录事件的发布者的线程信息。currentPostingThreadState 维护一个eventQueue，

首先，将 Event 插入了 eventQueue 中，之后将 isMainThread 等信息进行填充。同时将 postingState 的 isPosting 置为了 true，使得事件 post 的过程中当前线程的其他 post 事件无法被相应，当 post 过程结束后，再将其置为true。

while 循环中遍历队列中所有event,调用 postSingleEvent(eventQueue.remove(0), postingState);

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

currentPostingThreadState 的创建

    private final ThreadLocal<PostingThreadState> currentPostingThreadState = new ThreadLocal<PostingThreadState>() {
        @Override
        protected PostingThreadState initialValue() {
            return new PostingThreadState();
        }
    };

通过ThreadLocal来保存currentPostingThreadState。
ThreadLocal 作用：是一个用于创建线程局部变量的类。它创建的变量只能被当前线程访问，其他线程则无法访问和修改。（比如Looper 的创建）

postSingleEvent、 postSingleEventForEventType、 postToSubscription

通过 postSingleEventForEventType 来进行搜寻对应Subscription，如果 Event 是子 Event，则获取它的所有父 Event 列表，再遍历列表进行搜索查询。否则直接调用 postSingleEventForEventType 进行搜索查询


    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);
            }
//如果在没有找到对应的 subscription，创建一个NoSubscriberEvent 再调用 post 请求。这样无论 event 是否有 Subscriber，它都会进行一次检测。
            if (sendNoSubscriberEvent && eventClass != NoSubscriberEvent.class &&
                    eventClass != SubscriberExceptionEvent.class) {
                post(new NoSubscriberEvent(this, event));
            }
        }
    }

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

postSingleEventForEventType方法根据 event 找到了所有对应的 Subscription，然后遍历 subscription列表调用 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);
        }
    }

postToSubscription方法是对订阅者线程进行判断。采用不同的 Poster 进行入队操作，通过队列的方式进行一一处理。对某些特殊情况则直接调用invokeSubscriber(subscription, event) 进行处理。在 Poster 内部调用的是 invokeSubscriber(PendingPost)

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

/**
 * Invokes the subscriber if the subscriptions is still active. Skipping subscriptions prevents race conditions
 * between {@link #unregister(Object)} and event delivery. Otherwise the event might be delivered after the
 * subscriber unregistered. This is particularly important for main thread delivery and registrations bound to the
 * live cycle of an Activity or Fragment.
 */
void invokeSubscriber(PendingPost pendingPost) {
    Object event = pendingPost.event;
    Subscription subscription = pendingPost.subscription;
    PendingPost.releasePendingPost(pendingPost);
    if (subscription.active) {
        invokeSubscriber(subscription, event);
    }
}

invokeSubscriber(pendingPost)在内部判断了 Subscription 的 active 状态，如果为 active(true)，再调用 invokeSubscriber(subscription, event) 方法对 Method 进行执行。这个 active 状态可以使得 unregister 的unsubscribeByEventType方法中的对应 Method 不再被执行( subscription.active = false;)

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

postSticky方法

 private final Map<Class<?>, Object> stickyEvents;
    /**
     * Posts the given event to the event bus and holds on to the event (because it is sticky). The most recent sticky
     * event of an event's type is kept in memory for future access by subscribers using {@link Subscribe#sticky()}.
     */
    public void postSticky(Object event) {
        synchronized (stickyEvents) {
            stickyEvents.put(event.getClass(), event);
        }
        // Should be posted after it is putted, in case the subscriber wants to remove immediately
        post(event);
    }

将event 加入到stickyEvents列表，再执行post方法

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 {
            logger.log(Level.WARNING, "Subscriber to unregister was not registered before: " + subscriber.getClass());
        }
    }

先判断了这个 Event 是否还未注册，若已注册则遍历执行 unsubscribeByEventType(subscriber, eventType)方法取消订阅，同时执行 typesBySubscriber.remove(subscriber);把Subcriber 所对应的信息从 typesBySubscriber 这个 Map 中移除。

unsubscribeByEventType方法

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

将 subscriptionsByEventType 中与 EventType 对应的Subscription 列表取出，遍历并将该 subscriber对应的 Subscription 的 active标记为 false 并删除。