有过Android开发经验的人相信对EventBus应该都有所了解，EventBus是一个开源库，它使用观察者模式对模块间的通信进行解藕。

下面是一个Android中使用EventBus的实例，相信大家都不陌生：

class MainActivity : AppCompatActivity() {    private val TAG = "MainActivity"    override fun onCreate(savedInstanceState: Bundle?) {        super.onCreate(savedInstanceState)        setContentView(R.layout.activity_main)        EventBus.getDefault().register(this)        event_btn_1.setOnClickListener {            Thread(Runnable { EventBus.getDefault().post(Event(1)) }).start()        }    }    @Subscribe(threadMode = ThreadMode.MAIN_ORDERED)    fun onReceive(event: Event) {        Log.i(TAG, "currentThread: ${Thread.currentThread().name} event = ${event.what}")    }    override fun onDestroy() {        super.onDestroy()        EventBus.getDefault().unregister(this)    }    class Event(var what: Int = 0)}

可以看到使用在项目中使用EventBus非常简单，主要包括以下几步：

1、在onCreate()方法中注册观察者；

2、定义一个方法，这个方法要使用@Subscribe注解（在上面例子中我们通过threadMode = ThreadMode.MAIN_ORDERED标记了onReceive()方法将在主线程中被调用）；

3、在onDestroy()方法中注销观察者（注意：这一点非常重要，如果不注销，就会导致内存泄露）

4、在其他地方调用EventBus的post()方法发送消息。

分析上面的代码和EventBus的使用步骤，我们大概会想到下面几个问题：

1、EventBus是怎么管理观察者的，如果我们在onCreate()方法中调用两次register()方法，当EventBus发送消息是会不会收到两条消息；

2、上面代码中我们使用了EventBus.getDefault()获取了一个EventBus对象，那么我们是不是可以配置适合自己的EventBus对象，EventBus可以进行哪些配置？

3、EventBus中的消息是怎么传递的？

4、EventBus是怎么进行线程切换的？

5、EventBus中有粘性事件，粘性事件是怎么实现的？

基于这几个问题，我们追踪一下EventBus的源码，我们从EventBus.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;    }    /**     * 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;        //订阅失败时是否抛出异常，默认时false，应当在开发阶段设置为true，以便我们排查问题        throwSubscriberException = builder.throwSubscriberException;        //是否允许事件继承，默认允许，比如事件A继承自事件B，当发送A消息时B的订阅也可以收到消息，如果将这个参数设置为false可以提升事件的发布效率        eventInheritance = builder.eventInheritance;        //自定义线程池        executorService = builder.executorService;    }

上面是getDefault()和EventBus的构造方法，我们可以知道通过getDefault()方法获取到的EventBus对象是一个单例对象。同时在EventBus()构造方法的注释中我们知道，每一个EventBus对象的事件传递都是分开的，如果我们在一个类中用EventBus对象A注册了观察者，要想这个类能收到消息，则必须在其他地方使用A发送消息。

通过EventBus的构造方法我们还可以了解到EventBusBuilder中其实主要加了一些调试EventBus时需要的配置，比如Log，比如订阅失败时是否抛出异常等。当然EventBusBuilder中也有两个主要参数，一个是eventInheritance一个是executorService，这两个参数的含义在上面代码注释中有说明。如果我们一次发送的事件很少，那么修改eventInhericatance并不能显著提高性能，另外设置自定义线程池时我们也要保证自定义的线程池不会被卡住，所以这两项操作也很少使用，所以大部分情况下我们使用默认EventBus对象就好。而且因为每一个EventBus对象的事件传递都是分开的，默认的EventBus对象又是单例的，所以使用默认的EventBus对象避免了将其从一个线程传递到另一个线程。

还有在EventBus的构造方法中我们看到三个消息发布器，分别是mainThreadPoster，backgroundPoster和asyncPoster，此时我们可以猜想，EventBus向不同的线程中发送消息使用的是不同的发布器，到底是不是我们一会验证。

1、订阅者注册

下面我们分析EventBus的register()方法，这个方法用来向EventBus中注册一个观察者，以便该观察者接收EventBus发送的事件。

    /**     * Registers the given subscriber to receive events. Subscribers must call {@link #unregister(Object)} once they     * are no longer interested in receiving events.     * 
     * 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();        //查找当前类subscriber类及其父类中用@Subscribe注解的方法        List subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);        synchronized (this) {            for (SubscriberMethod subscriberMethod : subscriberMethods) {                //依次订阅subscriber中用@Subscribe注解的方法                subscribe(subscriber, subscriberMethod);            }        }    }

register()方法的代码比较简单，查找观察者类subscriber中及其父类中所有接收消息的方法（即用@Subscribe注解修饰的方法），用SubscriberMethod类定义，然后依次调用subscribe()方法将subscriber类和SubscriberMethod添加到订阅列表中。查找SubscriberMethod的逻辑在SubscriberMethodFinder.findSubscriberMethods()方法中，查找SubscriberMethod的逻辑有两种一种是缓存中有FindState的索引，就根据索引查找（默认）；另一种是无论有没有FindState的索引，都通过反射查找，使用哪种方式可以通过EventBusBuilder.ignoreGeneratedIndex(boolean ignoreGeneratedIndex)方法配置。查找SubscriberMethod的逻辑并不简单，但这不是我们要分析的重点，所以先不看。

这里先看下SubscriberMethod类，以便后面理解subscribe(Object subscriber, SubscriberMethod subscriberMethod)方法。

/** 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) {        ......    }    ......    @Override    public int hashCode() {        return method.hashCode();    }}

这个类应该不用多说，下面我们分析subscribe(Object subscriber, SubscriberMethod 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 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();        //根据SubscriberMethod的优先级由高到低，将订阅者插入到订阅者列表        for (int i = 0; i <= size; i++) {            if (i == size || subscriberMethod.priority > subscriptions.get(i).subscriberMethod.priority) {                subscriptions.add(i, newSubscription);                break;            }        }                //将subscriber中订阅的所有消息类型放到subscribeEvents列表中，然后通过map与subscriber对应起来        List> subscribedEvents = typesBySubscriber.get(subscriber);        if (subscribedEvents == null) {            subscribedEvents = new ArrayList<>();            typesBySubscriber.put(subscriber, subscribedEvents);        }        subscribedEvents.add(eventType);                /**         * 如果SubscribeMethod是非粘性的，则订阅操作至此结束，         * 否则，查找EventBus中的粘性消息，发送给订阅者         * */                 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).                //stickyEvents是Map类型，这里为了提高遍历速度要先改变一下数据结构为set                Set, Object>> entries = stickyEvents.entrySet();                for (Map.Entry, 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);            }        }    }    //检查粘性事件并发送给订阅者    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.            postToSubscription(newSubscription, stickyEvent, isMainThread());        }    }

通过上面的代码我们发现，EventBus的注册流程并不复杂，就是拿到一个订阅者对象之后查找其接收消息的方法，然后用订阅者对象和接收消息的方法创建一个Subscription对象，并将Subscription对象放到某个消息类型的订阅列表中。同时还用typesBySubscriber记录了某个订阅对象订阅了哪些消息（这个在注销订阅者时会很重要）。最后如果订阅者接收消息的方法还接收粘性事件，就查找粘性事件列表，并把对应类型的粘性事件发送给订阅者。

上面代码中发送事件时调用了postToSubscription()方法，其实所有的事件发送都在这个方法中进行。

2、事件发送

我们知道发送粘性事件调用的是postSticky()方法，而发送非粘性事件是调用post()方法，下面是这两个方法的源码：

    /**     * 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) {        //将event存放到stickyEvents中        synchronized (stickyEvents) {            stickyEvents.put(event.getClass(), event);        }        // Should be posted after it is putted, in case the subscriber wants to remove immediately        //调用Post发送事件        post(event);    }        /** Posts the given event to the event bus. */    public void post(Object event) {        //通过currentPostingThreadState获取当前线程中的postingState，currentPostingThreadState是EventBus中ThreadLocal类型的final属性。postingState是通过currentPostingThreadState跟当前线程绑定到一起的。        PostingThreadState postingState = currentPostingThreadState.get();        //获取当前线程中要发送的消息列表        List