Event Bus 之 Otto(三）

理解 Otto 事件总线的工作原理及其实现细节

最新推荐文章于 2025-09-12 15:58:40 发布

weixin_34368949

最新推荐文章于 2025-09-12 15:58:40 发布

阅读量70

点赞数

CC 4.0 BY-SA版权

文章标签： python

原文链接：https://my.oschina.net/u/255456/blog/345666

本文深入解析 Otto 事件总线的注册和发布机制，包括如何通过 ThreadEnforcer 实现线程安全，ConcurrentMap 的 putIfAbsent 方法在事件注册过程中的作用，以及如何处理事件跨线程问题。详细解释了 producer 和 subscriber 的工作流程，以及事件处理的并发控制策略。

2019独角兽企业重金招聘Python工程师标准>>>

register 过程：

从代码注释可知，如果你在订阅一个事件类型时，这个类型已经注册了producer，那么EventBus会立即调用producer产生事件向 刚注册的 subscribers发布。

另外，一个事件类型只能对应一个producer，否则抛出异常。

还有就是要理解 ConcurrentMap 的 putIfAbsent 方法:如果指定的key-value 不存在则相当于put 操作，否则相当于get 操作。

/**
   * Registers all handler methods on {@code object} to receive events and producer methods to provide events.
   * <p>
   * If any subscribers are registering for types which already have a producer they will be called immediately
   * with the result of calling that producer.
   * <p>
   * If any producers are registering for types which already have subscribers, each subscriber will be called with
   * the value from the result of calling the producer.
   *
   * @param object object whose handler methods should be registered.
   * @throws NullPointerException if the object is null.
   */
   
  public void register(Object object) {
    ...
    enforcer.enforce(this);

    //提取 producer
    Map<Class<?>, EventProducer> foundProducers = handlerFinder.findAllProducers(object);
    for (Class<?> type : foundProducers.keySet()) {

      final EventProducer producer = foundProducers.get(type);
      EventProducer previousProducer = producersByType.putIfAbsent(type, producer);
      
      //checking if the previous producer existed
      //一个事件类型只能有一个生产者
      if (previousProducer != null) {
        throw new IllegalArgumentException("Producer method for type " + type + " found on type " + producer.target.getClass()
          + ", but already registered by type " + previousProducer.target.getClass() + ".");
      }
      
      Set<EventHandler> handlers = handlersByType.get(type);
      if (handlers != null && !handlers.isEmpty()) {
        for (EventHandler handler : handlers) {
          dispatchProducerResultToHandler(handler, producer);
        }
      }
    }

    // 提取 subscriber
    Map<Class<?>, Set<EventHandler>> foundHandlersMap = handlerFinder.findAllSubscribers(object);
    for (Class<?> type : foundHandlersMap.keySet()) {
      Set<EventHandler> handlers = handlersByType.get(type);
      if (handlers == null) {
        //concurrent put if absent
        Set<EventHandler> handlersCreation = new CopyOnWriteArraySet<EventHandler>();
        handlers = handlersByType.putIfAbsent(type, handlersCreation);
        if (handlers == null) {
            handlers = handlersCreation;
        }
      }
      final Set<EventHandler> foundHandlers = foundHandlersMap.get(type);
      handlers.addAll(foundHandlers);
    }

    //对于新注册的订阅者，如果有producer，则立即向订阅者发布最新事件
    for (Map.Entry<Class<?>, Set<EventHandler>> entry : foundHandlersMap.entrySet()) {
      Class<?> type = entry.getKey();
      EventProducer producer = producersByType.get(type);
      
          if (producer != null && producer.isValid()) {
                Set<EventHandler> foundHandlers = entry.getValue();
                for (EventHandler foundHandler : foundHandlers) {
                      if (!producer.isValid()) {
                        break;
                      }
                      if (foundHandler.isValid()) {
                        dispatchProducerResultToHandler(foundHandler, producer);
                      }
                }
            
          }      
    }
    
  }

post 过程：

将一个事件向所有的subscribers发布，如果某个handler发生异常将被无视 :D

如果一个事件没有相应的subscriber来处理，那么这个事件将被包装成 DeadEvent 并重新发布；

/**
   * Posts an event to all registered handlers.  This method will return successfully after the event has been posted to
   * all handlers, and regardless of any exceptions thrown by handlers.
   *
   * <p>If no handlers have been subscribed for {@code event}'s class, and {@code event} is not already a
   * {@link DeadEvent}, it will be wrapped in a DeadEvent and reposted.
   *
   * @param event event to post.
   * @throws NullPointerException if the event is null.
   */
  public void post(Object event) {
    if (event == null) {
      throw new NullPointerException("Event to post must not be null.");
    }
    enforcer.enforce(this);

    Set<Class<?>> dispatchTypes = flattenHierarchy(event.getClass());

    boolean dispatched = false;
    for (Class<?> eventType : dispatchTypes) {
      Set<EventHandler> wrappers = getHandlersForEventType(eventType);

      if (wrappers != null && !wrappers.isEmpty()) {
        dispatched = true;
        for (EventHandler wrapper : wrappers) {
          enqueueEvent(event, wrapper);
        }
      }
    }

    if (!dispatched && !(event instanceof DeadEvent)) {
      post(new DeadEvent(this, event));
    }

    dispatchQueuedEvents();
  }

跨线程问题

在register 和 post 方法中都有一个enforcer 变量，它是ThreadEnforcer的实现，用来限制register、post等方法调用的线程（一般只能在主线程中调用），你也可以实现自己的ThreadEnforcer来改变折中策略。

另外eventToDispatch 以及 isDispatching 变量都使用了ThreadLocal ，这些也为你实现自己的ThreadEnforcer策略提供了支持，同时还可以看出，Otto是不能跨线程发布事件的，如果确实需要这样做，要借助线程的Looper 或 AsyncTask 来实现。

  /** Thread enforcer for register, unregister, and posting events. */
  private final ThreadEnforcer enforcer;

  /** Queues of events for the current thread to dispatch. */
  private final ThreadLocal<ConcurrentLinkedQueue<EventWithHandler>> eventsToDispatch = new ThreadLocal<ConcurrentLinkedQueue<EventWithHandler>>() {
       
	  @Override protected ConcurrentLinkedQueue<EventWithHandler> initialValue() {
          return new ConcurrentLinkedQueue<EventWithHandler>();
        }
	  
      };

  /** True if the current thread is currently dispatching an event. */
  private final ThreadLocal<Boolean> isDispatching = new ThreadLocal<Boolean>() {
    @Override protected Boolean initialValue() {
      return false;
    }
  };

转载于:https://my.oschina.net/u/255456/blog/345666