• 通過(guò) SubscriberIndex 方式獲取
  findUsingInfo方法：

private List<SubscriberMethod> findUsingInfo(Class<?> subscriberClass) {
        // 通過(guò) prepareFindState 獲取到 FindState(保存找到的注解過(guò)的方法的狀態(tài))
        FindState findState = prepareFindState();

        // findState 與 subscriberClass 關(guān)聯(lián)
        findState.initForSubscriber(subscriberClass);
        while (findState.clazz != null) {
            // 獲取訂閱者信息
            // 通過(guò) SubscriberIndex 獲取 findState.clazz 對(duì)應(yīng)的 SubscriberInfo
            findState.subscriberInfo = getSubscriberInfo(findState);
            if (findState.subscriberInfo != null) {
                SubscriberMethod[] array = findState.subscriberInfo.getSubscriberMethods();
                for (SubscriberMethod subscriberMethod : array) {
                    if (findState.checkAdd(subscriberMethod.method, subscriberMethod.eventType)) {
                        // 逐個(gè)添加進(jìn) findState.subscriberMethods
                        findState.subscriberMethods.add(subscriberMethod);
                    }
                }
            } else {
                // 使用反射的方式獲取單個(gè)類(lèi)的訂閱方法
                findUsingReflectionInSingleClass(findState);
            }
            findState.moveToSuperclass();
        }
        return getMethodsAndRelease(findState);
    }

這個(gè)方法里面的涉及到的方法在上面講發(fā)射的時(shí)候都有了，這里就不重復(fù)了。引入一個(gè)新的接口：

• SubscriberInfo：

/**
 * Base class for generated index classes created by annotation processing.
 * 由批注處理創(chuàng)建的已生成索引類(lèi)的基類(lèi)
 */
public interface SubscriberInfo {
    Class<?> getSubscriberClass();

    SubscriberMethod[] getSubscriberMethods();

    SubscriberInfo getSuperSubscriberInfo();

    boolean shouldCheckSuperclass();
}

• AbstractSubscriberInfo是SubscriberInfo 實(shí)現(xiàn)的抽象類(lèi)

/**
 * Base class for generated subscriber meta info classes created by annotation processing.
 * 由批注處理創(chuàng)建的已生成訂閱服務(wù)器元信息類(lèi)的基類(lèi)
 */
public abstract class AbstractSubscriberInfo implements SubscriberInfo {
    private final Class subscriberClass;
    private final Class<? extends SubscriberInfo> superSubscriberInfoClass;
    private final boolean shouldCheckSuperclass;

    protected AbstractSubscriberInfo(Class subscriberClass, Class<? extends SubscriberInfo> superSubscriberInfoClass,
                                     boolean shouldCheckSuperclass) {
        this.subscriberClass = subscriberClass;
        this.superSubscriberInfoClass = superSubscriberInfoClass;
        this.shouldCheckSuperclass = shouldCheckSuperclass;
    }

    @Override
    public Class getSubscriberClass() {
        return subscriberClass;
    }

    @Override
    public SubscriberInfo getSuperSubscriberInfo() {
        if (superSubscriberInfoClass == null) {
            return null;
        }
        try {
            return superSubscriberInfoClass.newInstance();
        } catch (InstantiationException e) {
            throw new RuntimeException(e);
        } catch (IllegalAccessException e) {
            throw new RuntimeException(e);
        }
    }

    @Override
    public boolean shouldCheckSuperclass() {
        return shouldCheckSuperclass;
    }

    protected SubscriberMethod createSubscriberMethod(String methodName, Class<?> eventType) {
        return createSubscriberMethod(methodName, eventType, ThreadMode.POSTING, 0, false);
    }

    protected SubscriberMethod createSubscriberMethod(String methodName, Class<?> eventType, ThreadMode threadMode) {
        return createSubscriberMethod(methodName, eventType, threadMode, 0, false);
    }

    protected SubscriberMethod createSubscriberMethod(String methodName, Class<?> eventType, ThreadMode threadMode,
                                                      int priority, boolean sticky) {
        try {
            Method method = subscriberClass.getDeclaredMethod(methodName, eventType);
            return new SubscriberMethod(method, eventType, threadMode, priority, sticky);
        } catch (NoSuchMethodException e) {
            throw new EventBusException("Could not find subscriber method in " + subscriberClass +
                    ". Maybe a missing ProGuard rule?", e);
        }
    }
}

• SimpleSubscriberInfo最終繼承上面的抽象類(lèi)

/**
 * Uses {@link SubscriberMethodInfo} objects to create {@link SubscriberMethod} objects on demand.
 * 使用 SubscriberMethodInfo 對(duì)象根據(jù)需要?jiǎng)?chuàng)建 SubscriberMethod 對(duì)象。
 */
public class SimpleSubscriberInfo extends AbstractSubscriberInfo {

    private final SubscriberMethodInfo[] methodInfos;

    public SimpleSubscriberInfo(Class subscriberClass, boolean shouldCheckSuperclass, SubscriberMethodInfo[] methodInfos) {
        super(subscriberClass, null, shouldCheckSuperclass);
        this.methodInfos = methodInfos;
    }

    @Override
    public synchronized SubscriberMethod[] getSubscriberMethods() {
        int length = methodInfos.length;
        SubscriberMethod[] methods = new SubscriberMethod[length];
        for (int i = 0; i < length; i++) {
            SubscriberMethodInfo info = methodInfos[i];
            methods[i] = createSubscriberMethod(info.methodName, info.eventType, info.threadMode,
                    info.priority, info.sticky);
        }
        return methods;
    }
}

• 最后就是要?jiǎng)?chuàng)建出的 SubscriberMethod 對(duì)象

/**
 * Used internally by EventBus and generated subscriber indexes.
 *
 * 封裝了EventBus中的參數(shù)，就是一個(gè)EventBus訂閱方法包裝類(lèi)
 */
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();
            // Don't use method.equals because of http://code.google.com/p/android/issues/detail?id=7811#c6
            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();
    }
}

到這里索引也分析完了，索引的具體使用：http://www.itdecent.cn/p/1e624bf9144d

接下來(lái)注冊(cè)的關(guān)鍵性一步：將訂閱者和訂閱者放方法形成訂閱關(guān)系
subscribe方法：

// Must be called in synchronized block  必須組同步塊中調(diào)用
    private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
        Class<?> eventType = subscriberMethod.eventType;

        // 創(chuàng)建 Subscription 封裝訂閱者和訂閱方法信息
        Subscription newSubscription = new Subscription(subscriber, subscriberMethod);

        // 可并發(fā)讀寫(xiě)的 ArrayList（CopyOnWriteArrayList)），key為 EventType，value為 Subscriptions
        // 根據(jù)事件類(lèi)型從 subscriptionsByEventType 這個(gè) Map 中獲取 Subscription 集合
        CopyOnWriteArrayList<Subscription> subscriptions = subscriptionsByEventType.get(eventType);

        // 如果為 null，表示還沒(méi)有（注冊(cè)）訂閱過(guò)，創(chuàng)建并 put 進(jìn) Map
        if (subscriptions == null) {
            subscriptions = new CopyOnWriteArrayList<>();
            subscriptionsByEventType.put(eventType, subscriptions);
        } else {
            // 若subscriptions中已經(jīng)包含newSubscription，表示該newSubscription已經(jīng)被訂閱過(guò)，拋出異常
            if (subscriptions.contains(newSubscription)) {
                throw new EventBusException("Subscriber " + subscriber.getClass() + " already registered to event "
                        + eventType);
            }
        }

        // 按照優(yōu)先級(jí)插入subscriptions
        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;
            }
        }

        // key為訂閱者，value為eventType，用來(lái)存放訂閱者中的事件類(lèi)型
        List<Class<?>> subscribedEvents = typesBySubscriber.get(subscriber);
        if (subscribedEvents == null) {
            subscribedEvents = new ArrayList<>();
            typesBySubscriber.put(subscriber, subscribedEvents);
        }

        // 將EventType放入subscribedEvents的集合中
        subscribedEvents.add(eventType);

        //判斷是否為Sticky事件
        if (subscriberMethod.sticky) {

            //判斷是否設(shè)置了事件繼承
            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>).
                // 獲取到所有Sticky事件的Set集合
                Set<Map.Entry<Class<?>, Object>> entries = stickyEvents.entrySet();

                //遍歷所有Sticky事件
                for (Map.Entry<Class<?>, Object> entry : entries) {
                    Class<?> candidateEventType = entry.getKey();

                    //判斷當(dāng)前事件類(lèi)型是否為黏性事件或者其子類(lèi)
                    if (eventType.isAssignableFrom(candidateEventType)) {
                        Object stickyEvent = entry.getValue();

                        // 執(zhí)行設(shè)置了 sticky 模式的訂閱方法
                        checkPostStickyEventToSubscription(newSubscription, stickyEvent);
                    }
                }
            } else {
                Object stickyEvent = stickyEvents.get(eventType);
                checkPostStickyEventToSubscription(newSubscription, stickyEvent);
            }
        }
    }

• 這里涉及到一個(gè)類(lèi)Subscription：

// 封裝訂閱者和訂閱方法信息
final class Subscription {
    final Object subscriber; // 訂閱者對(duì)象
    final SubscriberMethod subscriberMethod; // 訂閱的方法
}

• 檢查有沒(méi)有post粘性的事件

private void checkPostStickyEventToSubscription(Subscription newSubscription, Object stickyEvent) {
        if (stickyEvent != null) {
            // If the subscriber is trying to abort the event, it will fail (event is not tracked in posting state)
            // --> Strange corner case, which we don't take care of here.
            // 如果訂閱者試圖中止事件，它將失?。ㄔ诎l(fā)布狀態(tài)下不跟蹤事件）情況，我們?cè)谶@里不處理。
            postToSubscription(newSubscription, stickyEvent, isMainThread());
        }
    }

• postToSubscription方法： 這里調(diào)用主要是為了檢查沒(méi)有注冊(cè)之前是否發(fā)送了黏性事件

/**
     * 訂閱者五種線(xiàn)程模式的特點(diǎn)對(duì)應(yīng)的就是以上代碼，簡(jiǎn)單來(lái)講就是訂閱者指定了在哪個(gè)線(xiàn)程訂閱事件，無(wú)論發(fā)布者在哪個(gè)線(xiàn)程，它都會(huì)將事件發(fā)布到訂閱者指定的線(xiàn)程
     * @param subscription
     * @param event
     * @param isMainThread
     */
    private void postToSubscription(Subscription subscription, Object event, boolean isMainThread) {
        switch (subscription.subscriberMethod.threadMode) {

            // 訂閱線(xiàn)程跟隨發(fā)布線(xiàn)程，EventBus 默認(rèn)的訂閱方式
            case POSTING:
                invokeSubscriber(subscription, event);  // 訂閱線(xiàn)程和發(fā)布線(xiàn)程相同，直接訂閱
                break;

            // 訂閱線(xiàn)程為主線(xiàn)程
            case MAIN:
                if (isMainThread) { // 如果 post是在 UI 線(xiàn)程，直接調(diào)用 invokeSubscriber
                    invokeSubscriber(subscription, event);
                } else {

                    // 如果不在 UI 線(xiàn)程，用 mainThreadPoster 進(jìn)行調(diào)度，即上文講述的 HandlerPoster 的 Handler 異步處理，將訂閱線(xiàn)程切換到主線(xiàn)程訂閱
                    mainThreadPoster.enqueue(subscription, event);
                }
                break;

            // 訂閱線(xiàn)程為主線(xiàn)程
            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;

            // 訂閱線(xiàn)程為后臺(tái)線(xiàn)程
            case BACKGROUND:

                // 如果在 UI 線(xiàn)程，則將 subscription 添加到后臺(tái)線(xiàn)程的線(xiàn)程池
                if (isMainThread) {
                    backgroundPoster.enqueue(subscription, event);
                } else {
                    // 不在UI線(xiàn)程，直接分發(fā)
                    invokeSubscriber(subscription, event);
                }
                break;

            // 訂閱線(xiàn)程為異步線(xiàn)程
            case ASYNC:
                // 使用線(xiàn)程池線(xiàn)程訂閱
                asyncPoster.enqueue(subscription, event);
                break;
            default:
                throw new IllegalStateException("Unknown thread mode: " + subscription.subscriberMethod.threadMode);
        }
    }

到這里注冊(cè)流程就分析完了，下面貼上一張整體流程圖：

注冊(cè)流程圖

3.書(shū)寫(xiě)接收訂閱事件的方法

@Subscribe(threadMode = ThreadMode.POSTING,sticky = false,priority = 4)
    public void onEventThread(EventCenter eventCenter){
        switch (eventCenter.getEventType()) {
        case EventType.ONE:
            Log.e("MainActivity", eventCenter.getEventType());
            break;

        default:
            break;
        }
        // EventBus.getDefault().cancelEventDelivery(eventCenter);
    }

• 這里主要涉及到注解及黏性事件。
  注解：

@Documented  // 命名為 java doc 文檔
@Retention(RetentionPolicy.RUNTIME) // 指定在運(yùn)行時(shí)有效，即在運(yùn)行時(shí)能保持這個(gè) Subscribe
@Target({ElementType.METHOD})  // 指定類(lèi)型為 METHOD，表名用來(lái)描述方法
public @interface Subscribe {

    // 指定線(xiàn)程模式，可以指定在 Subscribe 中接收的 Event 所處的線(xiàn)程
    ThreadMode threadMode() default ThreadMode.POSTING;  // 訂閱線(xiàn)程的模式，默認(rèn)從哪個(gè)線(xiàn)程發(fā)送，就從哪個(gè)線(xiàn)程訂閱

    /**
     * If true, delivers the most recent sticky event (posted with
     * {@link EventBus#postSticky(Object)}) to this subscriber (if event available).
     * 粘性事件是事件消費(fèi)者在事件發(fā)布之后才注冊(cè)，依然能接收到該事件的特殊類(lèi)型。
     */
    boolean sticky() default false;

    /** Subscriber priority to influence the order of event delivery.
     * Within the same delivery thread ({@link ThreadMode}), higher priority subscribers will receive events before
     * others with a lower priority. The default priority is 0. Note: the priority does *NOT* affect the order of
     * delivery among subscribers with different {@link ThreadMode}s! 
     * 數(shù)值越高優(yōu)先級(jí)越大，越先接收事件
     * */
    int priority() default 0;
}

總結(jié)：

• 粘性事件是事件消費(fèi)者在事件發(fā)布之后才注冊(cè)，依然能接收到該事件的特殊類(lèi)型
• 任何時(shí)候在任何一個(gè)訂閱了該事件的訂閱者中的任何地方，都可以通 EventBus.getDefault().getStickyEvent(MyEvent.class)來(lái)取得該類(lèi)型事件的最后一次緩存。
• 優(yōu)先級(jí)priority數(shù)值越高優(yōu)先級(jí)越大，越先接收事件

線(xiàn)程模式ThreadMode

/**
 * Each subscriber method has a thread mode, which determines in which thread the method is to be called by EventBus.
 * EventBus takes care of threading independently from the posting thread.
 *
 * 每個(gè)訂閱服務(wù)器方法都有一個(gè)線(xiàn)程模式，該模式?jīng)Q定EventBus在哪個(gè)線(xiàn)程中調(diào)用該方法。EventBus獨(dú)立于發(fā)布線(xiàn)程來(lái)處理線(xiàn)程。
 * 
 * @see EventBus#register(Object)
 * @author Markus
 */
public enum ThreadMode {
    /**
     * Subscriber will be called directly in the same thread, which is posting the event. This is the default. Event delivery
     * implies the least overhead because it avoids thread switching completely. Thus this is the recommended mode for
     * simple tasks that are known to complete in a very short time without requiring the main thread. Event handlers
     * using this mode must return quickly to avoid blocking the posting thread, which may be the main thread.
     *
     * 訂閱服務(wù)器將直接在發(fā)布事件的同一線(xiàn)程中調(diào)用。這是默認(rèn)設(shè)置。事件傳遞意味著開(kāi)銷(xiāo)最小，因?yàn)樗耆苊饬司€(xiàn)程切換。
     * 因此，對(duì)于已知在非常短的時(shí)間內(nèi)完成而不需要主線(xiàn)程的簡(jiǎn)單任務(wù)，建議使用這種模式。
     * 使用此模式的事件處理程序必須快速返回，以避免阻塞可能是主線(xiàn)程的發(fā)布線(xiàn)程。
     */
    POSTING,  // EventBus 默認(rèn)的線(xiàn)程模式 就是訂閱的線(xiàn)程和發(fā)送事件的線(xiàn)程為同一線(xiàn)程

    /**
     * On Android, subscriber will be called in Android's main thread (UI thread). If the posting thread is
     * the main thread, subscriber methods will be called directly, blocking the posting thread. Otherwise the event
     * is queued for delivery (non-blocking). Subscribers using this mode must return quickly to avoid blocking the main thread.
     * If not on Android, behaves the same as {@link #POSTING}.
     *
     *
     * 在A(yíng)ndroid上，用戶(hù)將在A(yíng)ndroid的主線(xiàn)程（UI線(xiàn)程）中被調(diào)用。
     * 如果發(fā)布線(xiàn)程是主線(xiàn)程，則將直接調(diào)用訂閱方法，從而阻塞發(fā)布線(xiàn)程。否則，事件將排隊(duì)等待傳遞（非阻塞）。
     * 使用此模式的訂閱必須快速返回，以避免阻塞主線(xiàn)程。如果不在A(yíng)ndroid上，其行為與 POSTING 發(fā)布相同。
     * 因?yàn)榘沧恐骶€(xiàn)程阻塞會(huì)發(fā)生 ANR 異常
     */
    MAIN,  // 主線(xiàn)程

    /**
     * On Android, subscriber will be called in Android's main thread (UI thread). Different from {@link #MAIN},
     * the event will always be queued for delivery. This ensures that the post call is non-blocking.
     *
     * 在A(yíng)ndroid上，用戶(hù)將在A(yíng)ndroid的主線(xiàn)程（UI線(xiàn)程）中被調(diào)用。與 MAIN 不同，事件將始終排隊(duì)等待傳遞。這樣可以確保后調(diào)用不阻塞
     */
    MAIN_ORDERED, // 主線(xiàn)程

    /**
     * On Android, subscriber will be called in a background thread. If posting thread is not the main thread, subscriber methods
     * will be called directly in the posting thread. If the posting thread is the main thread, EventBus uses a single
     * background thread, that will deliver all its events sequentially. Subscribers using this mode should try to
     * return quickly to avoid blocking the background thread. If not on Android, always uses a background thread.
     *
     * 在A(yíng)ndroid上，訂閱將在后臺(tái)線(xiàn)程中被調(diào)用。如果發(fā)布線(xiàn)程不是主線(xiàn)程，則將直接在發(fā)布線(xiàn)程中調(diào)用訂閱方法。
     * 如果發(fā)布線(xiàn)程是主線(xiàn)程，那么 eventBus 使用單個(gè)后臺(tái)線(xiàn)程，該線(xiàn)程將按順序傳遞其所有事件。
     * 使用此模式的訂閱應(yīng)嘗試快速返回，以避免阻塞后臺(tái)線(xiàn)程。如果不在A(yíng)ndroid上，則始終使用后臺(tái)線(xiàn)程。
     *
     */
    BACKGROUND,  // 后臺(tái)線(xiàn)程

    /**
     * Subscriber will be called in a separate thread. This is always independent from the posting thread and the
     * main thread. Posting events never wait for subscriber methods using this mode. Subscriber methods should
     * use this mode if their execution might take some time, e.g. for network access. Avoid triggering a large number
     * of long running asynchronous subscriber methods at the same time to limit the number of concurrent threads. EventBus
     * uses a thread pool to efficiently reuse threads from completed asynchronous subscriber notifications.
     *
     * 將在單獨(dú)的線(xiàn)程中調(diào)用訂閱服務(wù)器。這始終獨(dú)立于發(fā)布線(xiàn)程和主線(xiàn)程。
     * 發(fā)布事件從不等待使用此模式的訂閱方法。
     * 如果訂閱服務(wù)器方法的執(zhí)行可能需要一些時(shí)間，例如用于網(wǎng)絡(luò)訪(fǎng)問(wèn)，則應(yīng)使用此模式。
     * 避免同時(shí)觸發(fā)大量長(zhǎng)時(shí)間運(yùn)行的異步訂閱服務(wù)器方法，以限制并發(fā)線(xiàn)程的數(shù)量。
     * EventBus使用線(xiàn)程池來(lái)有效地重用已完成的異步訂閱服務(wù)器通知中的線(xiàn)程。
     *
     */
    ASYNC // 異步線(xiàn)程
}

4.發(fā)送事件給訂閱者

// 發(fā)送黏性事件
EventBus.getDefault().postSticky(new EventCenter<>(EventType.ONE));
// 發(fā)送普通事件
EventBus.getDefault().post(new EventCenter<>(EventType.ONE));

• postSticky方法：

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 如果訂閱者希望立即刪除，則應(yīng)在放入后發(fā)布
        post(event);
    }

• post方法：

/**
     * Posts the given event to the event bus.
     * 將給定事件發(fā)布到事件總線(xiàn)
     */
    public void post(Object event) {

        // 獲取當(dāng)前線(xiàn)程的 posting 狀態(tài)
        PostingThreadState postingState = currentPostingThreadState.get();

        // 獲取當(dāng)前事件隊(duì)列
        List<Object> eventQueue = postingState.eventQueue;

        // 將事件添加進(jìn)當(dāng)前線(xiàn)程的事件隊(duì)列
        eventQueue.add(event);

        // 判斷是否正在posting（發(fā)送)）
        if (!postingState.isPosting) {
            postingState.isMainThread = isMainThread();
            postingState.isPosting = true;

            // 如果已經(jīng)取消，則拋出異常
            if (postingState.canceled) {
                throw new EventBusException("Internal error. Abort state was not reset");
            }
            try {
                while (!eventQueue.isEmpty()) { // 循環(huán)從事件隊(duì)列中取出事件
                    // 發(fā)送事件
                    postSingleEvent(eventQueue.remove(0), postingState);
                }
            } finally {
                // 狀態(tài)復(fù)原
                postingState.isPosting = false;
                postingState.isMainThread = false;
            }
        }
    }

• 發(fā)送事件的線(xiàn)程封裝類(lèi) PostingThreadState

/**
     * For ThreadLocal, much faster to set (and get multiple values).
     *
     * 發(fā)送事件的線(xiàn)程封裝類(lèi)
     */
    final static class PostingThreadState {
        final List<Object> eventQueue = new ArrayList<>();  // 事件隊(duì)列
        boolean isPosting; // 是否正在 posting
        boolean isMainThread;  // 是否為主線(xiàn)程
        Subscription subscription;
        Object event;
        boolean canceled; // 是否已經(jīng)取消
    }

• postSingleEvent 發(fā)送方法：

/**
     * 發(fā)送事件
     *
     * EventBus 用 ThreadLocal 存儲(chǔ)每個(gè)線(xiàn)程的 PostingThreadState，一個(gè)存儲(chǔ)了事件發(fā)布狀態(tài)的類(lèi)，
     * 當(dāng) post 一個(gè)事件時(shí)，添加到事件隊(duì)列末尾，等待前面的事件發(fā)布完畢后再拿出來(lái)發(fā)布，
     * 這里看事件發(fā)布的關(guān)鍵代碼postSingleEvent()
     */
    private void postSingleEvent(Object event, PostingThreadState postingState) throws Error {
        Class<?> eventClass = event.getClass();
        boolean subscriptionFound = false;
        if (eventInheritance) { // 處理繼承事件
            List<Class<?>> eventTypes = lookupAllEventTypes(eventClass); // 查找所有相關(guān)父類(lèi)及接口
            int countTypes = eventTypes.size();
            for (int h = 0; h < countTypes; h++) {
                Class<?> clazz = eventTypes.get(h);
                subscriptionFound |= postSingleEventForEventType(event, postingState, clazz); // 將事件作為特定的類(lèi)型事件進(jìn)行發(fā)送
            }
        } else {
            subscriptionFound = postSingleEventForEventType(event, postingState, eventClass);
        }
        if (!subscriptionFound) { // 沒(méi)有找到注冊(cè)的處理函數(shù)，即還沒(méi)有注冊(cè)能夠處理該事件的函數(shù)，（異常處理）
            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)); // 如果沒(méi)有人和訂閱者訂閱發(fā)送 NoSubscriberEvent
            }
        }
    }

• lookupAllEventTypes方法：

/**
     * Looks up all Class objects including super classes and interfaces. Should also work for interfaces.
     * 看看涉及到lookupAllEventTypes，就是查找到發(fā)生事件的所有相關(guān)類(lèi)（父類(lèi)）
     */
    private static List<Class<?>> lookupAllEventTypes(Class<?> eventClass) {
        synchronized (eventTypesCache) {
            List<Class<?>> eventTypes = eventTypesCache.get(eventClass);
            if (eventTypes == null) {
                eventTypes = new ArrayList<>();
                Class<?> clazz = eventClass;
                while (clazz != null) {
                    eventTypes.add(clazz);
                    addInterfaces(eventTypes, clazz.getInterfaces());
                    clazz = clazz.getSuperclass();
                }
                eventTypesCache.put(eventClass, eventTypes);
            }
            return eventTypes;
        }
    }

/**
     * Recurses through super interfaces. 遍歷父類(lèi)接口
     */
    static void addInterfaces(List<Class<?>> eventTypes, Class<?>[] interfaces) {
        for (Class<?> interfaceClass : interfaces) {
            if (!eventTypes.contains(interfaceClass)) {
                eventTypes.add(interfaceClass);
                addInterfaces(eventTypes, interfaceClass.getInterfaces()); // 遞歸
            }
        }
    }

• postSingleEventForEventType方法：

// 進(jìn)一步深入的發(fā)送事件函數(shù)：
    private boolean postSingleEventForEventType(Object event, PostingThreadState postingState, Class<?> eventClass) {
        CopyOnWriteArrayList<Subscription> subscriptions;
        synchronized (this) {
            subscriptions = subscriptionsByEventType.get(eventClass); // 查找是否存在處理eventClass的注冊(cè)處理函數(shù) （查找該事件的所有訂閱者）
        }
        if (subscriptions != null && !subscriptions.isEmpty()) {  // 有對(duì)應(yīng)的處理函數(shù)
            for (Subscription subscription : subscriptions) {  // 依次分發(fā)
                postingState.event = event;
                postingState.subscription = subscription;
                boolean aborted = false;  // 用于確定是否需要繼續(xù)分發(fā)，也許已經(jīng)被攔截不需要分發(fā)了
                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;
    }

最終走了這個(gè)方法postToSubscription()進(jìn)行事件發(fā)送

/**
     * 訂閱者五種線(xiàn)程模式的特點(diǎn)對(duì)應(yīng)的就是以上代碼，簡(jiǎn)單來(lái)講就是訂閱者指定了在哪個(gè)線(xiàn)程訂閱事件，無(wú)論發(fā)布者在哪個(gè)線(xiàn)程，它都會(huì)將事件發(fā)布到訂閱者指定的線(xiàn)程
     * @param subscription
     * @param event
     * @param isMainThread
     */
    private void postToSubscription(Subscription subscription, Object event, boolean isMainThread) {
        switch (subscription.subscriberMethod.threadMode) {

            // 訂閱線(xiàn)程跟隨發(fā)布線(xiàn)程，EventBus 默認(rèn)的訂閱方式
            case POSTING:
                invokeSubscriber(subscription, event);  // 訂閱線(xiàn)程和發(fā)布線(xiàn)程相同，直接訂閱
                break;

            // 訂閱線(xiàn)程為主線(xiàn)程
            case MAIN:
                if (isMainThread) { // 如果 post是在 UI 線(xiàn)程，直接調(diào)用 invokeSubscriber
                    invokeSubscriber(subscription, event);
                } else {

                    // 如果不在 UI 線(xiàn)程，用 mainThreadPoster 進(jìn)行調(diào)度，即上文講述的 HandlerPoster 的 Handler 異步處理，將訂閱線(xiàn)程切換到主線(xiàn)程訂閱
                    mainThreadPoster.enqueue(subscription, event);
                }
                break;

            // 訂閱線(xiàn)程為主線(xiàn)程
            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;

            // 訂閱線(xiàn)程為后臺(tái)線(xiàn)程
            case BACKGROUND:

                // 如果在 UI 線(xiàn)程，則將 subscription 添加到后臺(tái)線(xiàn)程的線(xiàn)程池
                if (isMainThread) {
                    backgroundPoster.enqueue(subscription, event);
                } else {
                    // 不在UI線(xiàn)程，直接分發(fā)
                    invokeSubscriber(subscription, event);
                }
                break;

            // 訂閱線(xiàn)程為異步線(xiàn)程
            case ASYNC:
                // 使用線(xiàn)程池線(xiàn)程訂閱
                asyncPoster.enqueue(subscription, event);
                break;
            default:
                throw new IllegalStateException("Unknown thread mode: " + subscription.subscriberMethod.threadMode);
        }
    }

到這里事件發(fā)送也分析完了，老規(guī)矩附上流程圖：

post事件流程圖

由于篇幅所限，剩下的內(nèi)容傳送門(mén)：http://www.itdecent.cn/p/f61b8e7da6b4