guava eventbus 原理+源码分析
前言:
guava提供的eventbus可以很方便的处理一对多的事件问题， 最近正好使用到了,做个小结,使用的demo网上已经很多了,不再赘述,本文主要是源码分析+使用注意点+新老版本eventbus实现方式对比
一.原理
将定义的hander注册到eventbus中，eventbus遍历该handler及其父类中含有@subscribe注解的方法，封装成subscriber对象，一个event会对应多个方法,Map<EventType.class,List<Subscriber>>,但既然是guava出品,这种情况下一定会用自己家的MultiMap了,接收到event后根据类型匹配对应的subscriber去执行,接下来从源码角度探究下
二.源码分析
主要分析注册与分发处理,会贴相关的源码的注释(guava版本github 2021 1月版本),方便你阅读
1.注册流程
分析之前我们先简要拓展下关于guava cache的用法,compute if absent,不存在则计算,对应getOrLoad方法(暴露给用户的是get()),有则直接返回,
注册流程抓住一个关键点即可,即一个subscriber对应一个被@subscriber标记的method,为了方便阅读,我把代码贴到一起
1 /** Registers all subscriber methods on the given listener object. */
2 void register(Object listener) {
3 // key-eventType.class value-List<Subscriber>,一个subscriber对应一个方法
4 Multimap<Class<?>, Subscriber> listenerMethods = findAllSubscribers(listener);
5
6 for (Entry<Class<?>, Collection<Subscriber>> entry : listenerMethods.asMap().entrySet()) {
7 Class<?> eventType = entry.getKey();
8 Collection<Subscriber> eventMethodsInListener = entry.getValue();
9 // 并发读写
10 CopyOnWriteArraySet<Subscriber> eventSubscribers = subscribers.get(eventType);
11
12 if (eventSubscribers == null) {
13 CopyOnWriteArraySet<Subscriber> newSet = new CopyOnWriteArraySet<>();
14 // eventType.class不存在时才put,concurrenthashmap的putIfAbsent()
15 // 有可能为null,用newSet替换
16 eventSubscribers =
17 MoreObjects.firstNonNull(subscribers.putIfAbsent(eventType, newSet), newSet);
18 }
19 // 添加
20 eventSubscribers.addAll(eventMethodsInListener);
21 }
22 }
23
24
25 /**
26 * Returns all subscribers for the given listener grouped by the type of event they subscribe to.
27 */
28 private Multimap<Class<?>, Subscriber> findAllSubscribers(Object listener) {
29 Multimap<Class<?>, Subscriber> methodsInListener = HashMultimap.create();
30 Class<?> clazz = listener.getClass();
31 for (Method method : getAnnotatedMethods(clazz)) {
32 Class<?>[] parameterTypes = method.getParameterTypes();
33 Class<?> eventType = parameterTypes[0];
34 // 创建subscriber时,如果未添加@AllowConcurrentEvents注解则生成同步的subscriber
35 methodsInListener.put(eventType, Subscriber.create(bus, listener, method));
36 }
37 return methodsInListener;
38 }
39
40 private static ImmutableList<Method> getAnnotatedMethods(Class<?> clazz) {
41 try {
42 return subscriberMethodsCache.getUnchecked(clazz);
43 } catch (UncheckedExecutionException e) {
44 throwIfUnchecked(e.getCause());
45 throw e;
46 }
47 }
48
49 // 映射关系缓存,getOrload
50 private static final LoadingCache<Class<?>, ImmutableList<Method>> subscriberMethodsCache =
51 CacheBuilder.newBuilder()
52 .weakKeys()
53 .build(
54 new CacheLoader<Class<?>, ImmutableList<Method>>() {
55 @Override
56 public ImmutableList<Method> load(Class<?> concreteClass) throws Exception {
57 return getAnnotatedMethodsNotCached(concreteClass);
58 }
59 });
60
61 private static ImmutableList<Method> getAnnotatedMethodsNotCached(Class<?> clazz) {
62 // 获得listener的所有父类及自身的class(包括接口)
63 Set<? extends Class<?>> supertypes = TypeToken.of(clazz).getTypes().rawTypes();
64 Map<MethodIdentifier, Method> identifiers = Maps.newHashMap();
65 for (Class<?> supertype : supertypes) {
66 for (Method method : supertype.getDeclaredMethods()) {
67 if (method.isAnnotationPresent(Subscribe.class) && !method.isSynthetic()) {
68 // TODO(cgdecker): Should check for a generic parameter type and error out
69 Class<?>[] parameterTypes = method.getParameterTypes();
70 // 参数校验,@subscribe注解的方法有且有能有一个非原始类型参数
71 checkArgument(
72 parameterTypes.length == 1,
73 "Method %s has @Subscribe annotation but has %s parameters. "
74 + "Subscriber methods must have exactly 1 parameter.",
75 method,
76 parameterTypes.length);
77
78 checkArgument(
79 !parameterTypes[0].isPrimitive(),
80 "@Subscribe method %s's parameter is %s. "
81 + "Subscriber methods cannot accept primitives. "
82 + "Consider changing the parameter to %s.",
83 method,
84 parameterTypes[0].getName(),
85 Primitives.wrap(parameterTypes[0]).getSimpleName());
86
87 MethodIdentifier ident = new MethodIdentifier(method);
88 // 重写的方法只放入一次
89 if (!identifiers.containsKey(ident)) {
90 identifiers.put(ident, method);
91 }
92 }
93 }
94 }
95 return ImmutableList.copyOf(identifiers.values());
96 }
97
98
99 // 创建subscriber
100 static Subscriber create(EventBus bus, Object listener, Method method) {
101 return isDeclaredThreadSafe(method)
102 ? new Subscriber(bus, listener, method)
103 : new SynchronizedSubscriber(bus, listener, method);
104 }
105
106 @VisibleForTesting
107 static final class SynchronizedSubscriber extends Subscriber {
108
109 private SynchronizedSubscriber(EventBus bus, Object target, Method method) {
110 super(bus, target, method);
111 }
112
113 @Override
114 void invokeSubscriberMethod(Object event) throws InvocationTargetException {
115 synchronized (this) {
116 super.invokeSubscriberMethod(event);
117 }
118 }
119 }
值得注意的是subscriber的生成,即便你使用了AsyncEventbus,却没有在处理方法上声明@AllowConcurrentEvents,那么在处理event时仍然是同步执行的,注册流程并发安全问题请看第三部分
2.分发流程
先看下如何获得event对应的subscriber
1 public void post(Object event) {
2 Iterator<Subscriber> eventSubscribers = subscribers.getSubscribers(event);
3 if (eventSubscribers.hasNext()) {
4 // 分发,dispatcher有三种实现,ImmediateDispatcher(同步处理event,深度优先)
5 // LegacyAsyncDispatcher(异步处理event)
6 // PerThreadQueuedDispatcher(默认,同步调用,广度优先) 内置队列,可以保证同一线程内的event的顺序
7 dispatcher.dispatch(event, eventSubscribers);
8 } else if (!(event instanceof DeadEvent)) {
9 // the event had no subscribers and was not itself a DeadEvent
10 // 把所有没有被订阅的event包装成deadevent,用户可以自己定义处理deadevent的方法,作为兜底
11 post(new DeadEvent(this, event));
12 }
13 }
14
15 Iterator<Subscriber> getSubscribers(Object event) {
16 //获得event的所有父类及自身的class(包括接口),从获取subscriber的流程来看,post一个event
17 // 时,除了调用该event的处理方法也会调用该event父类的处理方法
18 ImmutableSet<Class<?>> eventTypes = flattenHierarchy(event.getClass());
19
20 List<Iterator<Subscriber>> subscriberIterators =
21 Lists.newArrayListWithCapacity(eventTypes.size());
22
23 for (Class<?> eventType : eventTypes) {
24 CopyOnWriteArraySet<Subscriber> eventSubscribers = subscribers.get(eventType);
25 if (eventSubscribers != null) {
26 // eager no-copy snapshot
27 subscriberIterators.add(eventSubscribers.iterator());
28 }
29 }
30 // 类似flatmap,扁平化
31 return Iterators.concat(subscriberIterators.iterator());
32 }
33
34 @VisibleForTesting
35 static ImmutableSet<Class<?>> flattenHierarchy(Class<?> concreteClass) {
36 try {
37 return flattenHierarchyCache.getUnchecked(concreteClass);
38 } catch (UncheckedExecutionException e) {
39 throw Throwables.propagate(e.getCause());
40 }
41 }
42
43 private static final LoadingCache<Class<?>, ImmutableSet<Class<?>>> flattenHierarchyCache =
44 CacheBuilder.newBuilder()
45 .weakKeys()
46 .build(
47 new CacheLoader<Class<?>, ImmutableSet<Class<?>>>() {
48 // <Class<?>> is actually needed to compile
49 @SuppressWarnings("RedundantTypeArguments")
50 @Override
51 public ImmutableSet<Class<?>> load(Class<?> concreteClass) {
52 return ImmutableSet.<Class<?>>copyOf(
53 TypeToken.of(concreteClass).getTypes().rawTypes());
54 }
55 });
从代码可以看出,先对该event查询上级,最后把所有event对应的subscriber返回,因此触发一个event时,其父event的subscriber也会被调用
接下来看下post,流程eventbus有三种dispatcher(ImmediaDispatcher,PerThreadDispatcher,LegacyAsyncDispatcher)eventbus使用的是PerThreadDispatcher,AsyncEventBus使用LegacyAsyncDispatcher
①ImmediaDispatcher
从名字中的Immedia"即时"就能看出这个dispatcher收到event后会立即处理,不会进行异步处理
代码如下:
从图中可以看出ImmediaDispatcher是针对每个event,调用其全部的subscriber进行处理,即尽可能多的调用subscriber,所以是广度优先,这个dispatcher目前未被使用,了解即可
②PerThreadQueueDispatcher(默认的dispatcher)
同样从名称可以看出这种dispatcher是一个thread一个queue,那我们可以猜测内部有可能用了ThreadLocal,既然用了队列,说明想要起到一个缓冲event处理的过程
队列的缓冲功能使得dispatcher有能力吞吐更高的event,因此是一种深度优先策略,此外每线程每队列的方式保证了event处理过程是对于每个线程而言是有序的,同样是广度优先,对
每一个event都分发到相关的subscriber进行处理,除此之外还有一个值得称道的点,即Dispatching变量的使用,规避了递归产生的死循环问题
1 private static final class PerThreadQueuedDispatcher extends Dispatcher {
2
3 // This dispatcher matches the original dispatch behavior of EventBus.
4
5 /** Per-thread queue of events to dispatch. */
6 private final ThreadLocal<Queue<Event>> queue =
7 new ThreadLocal<Queue<Event>>() {
8 @Override
9 protected Queue<Event> initialValue() {
10 return Queues.newArrayDeque();
11 }
12 };
13
14 /** Per-thread dispatch state, used to avoid reentrant event dispatching. */
15 private final ThreadLocal<Boolean> dispatching =
16 new ThreadLocal<Boolean>() {
17 @Override
18 protected Boolean initialValue() {
19 return false;
20 }
21 };
22
23 @Override
24 void dispatch(Object event, Iterator<Subscriber> subscribers) {
25 checkNotNull(event);
26 checkNotNull(subscribers);
27 // 如果只从代码来看,PerThreadQueuedDispatcher的dispatch方法始终
28 // 是单线程调用,并不需要ThreadLocal,但从拓展的角度看,当用户自定义xxeventbus自己实现分发逻辑时,PerThreadQueuedDispatcher实现了线程安全的dispatch
29 //因为eventbus有可能会被多个线程调用,从框架的角度看,无论用户是否多线程调用,都应该要保证线程安全
30 // 引用issue 3530中 https://github.com/google/guava/issues/3530 的一个回答 if multiple threads are dispatching to this dispatcher, they will read different values for queueForThread and dispatching.
31 Queue<Event> queueForThread = queue.get();
32 queueForThread.offer(new Event(event, subscribers));
33
34 // 如果未开始分发事件则进行处理,解决subscriber递归调用post产生的死循环
35 if (!dispatching.get()) {
36 dispatching.set(true);
37 try {
38 Event nextEvent;
39 // 对每一个event,分发到相关的subscribers中
40 while ((nextEvent = queueForThread.poll()) != null) {
41 while (nextEvent.subscribers.hasNext()) {
42 nextEvent.subscribers.next().dispatchEvent(nextEvent.event);
43 }
44 }
45 } finally {
46 dispatching.remove();
47 queue.remove();
48 }
49 }
50 }
接下来看下刚刚说的dispatching的妙用demo
在guava-test下建立一个新的目录方便我们修改源码后进行测试,测试代码如下
Listener
1 /** 2 * @author tele 3 * @Description 4 * @create 2020-11-23 5 */ 6 public class Listener { 7 8 private final EventBus eventBus; 9 10 public Listener(EventBus eventBus) { 11 this.eventBus = eventBus; 12 } 13 14 @Subscribe 15 public void record(String s) { 16 eventBus.post(s); 17 System.out.println("receive:"+ s); 18 } 19 }
Producer
1 /** 2 * @author tele 3 * @Description 4 * @create 2020-11-23 5 */ 6 public class Producer { 7 8 public String produce() { 9 return "hello"; 10 } 11 }
Main
1 /**
2 * @author tele
3 * @Description
4 * @create 2020-11-23
5 */
6 public class Main {
7
8 public static void main(String[] args) {
9 EventBus eventBus = new EventBus();
10 Listener listener = new Listener(eventBus);
11 Producer producer = new Producer();
12 eventBus.register(listener);
13 String produce = producer.produce();
14 eventBus.post(produce);
15 }
16
17 }
代码很简单,问题在于Listener递归调用了post方法,按照代码示意运行后会栈溢出(队列中event堆积),receive:hello永远不会打印,可事实真的如此吗?
很奇怪是吗,并没有产生堆栈溢出的问题,反而是不停的输出receive:hello,接下来我们修改下PerThreadDispatcher的代码,将dispatching变量注释掉
再执行下demo
果然溢出了,关键点就在于dispatching变量对于同一线程的递归分发进行了处理,已经处理过就不再次进行分发,这样我们的递归调用不停的产生的event得以被处理
③LegacyAsyncDispatcher
看名字挺奇怪的,但有async字样,所以是异步的dispatcher,LegacyAsyncDispacther是AsyncEventBus的专用dispatcher,由于将event对应的subscriber拆分后入队,多线程情况下无法保证event入队顺序,也就无法保证subscriber的调用顺序,但这样处理实现了深度优先,即尽可能多的调用不同的event的subscriber,与PerThreadDispatcher相比代码难度小了不少,由于AsyncEventBus的初始化需要传入线程池参数,所以AsyncEventBus实现了真正的异步处理
1 /** Implementation of a {@link #legacyAsync()} dispatcher. */
2 private static final class LegacyAsyncDispatcher extends Dispatcher {
3
4 // This dispatcher matches the original dispatch behavior of AsyncEventBus.
5 //
6 // We can't really make any guarantees about the overall dispatch order for this dispatcher in
7 // a multithreaded environment for a couple reasons:
8 //
9 // 1. Subscribers to events posted on different threads can be interleaved with each other
10 // freely. (A event on one thread, B event on another could yield any of
11 // [a1, a2, a3, b1, b2], [a1, b2, a2, a3, b2], [a1, b2, b3, a2, a3], etc.)
12 // 2. It's possible for subscribers to actually be dispatched to in a different order than they
13 // were added to the queue. It's easily possible for one thread to take the head of the
14 // queue, immediately followed by another thread taking the next element in the queue. That
15 // second thread can then dispatch to the subscriber it took before the first thread does.
16 //
17 // All this makes me really wonder if there's any value in queueing here at all. A dispatcher
18 // that simply loops through the subscribers and dispatches the event to each would actually
19 // probably provide a stronger order guarantee, though that order would obviously be different
20 // in some cases.
21
22 /** Global event queue. */
23 private final ConcurrentLinkedQueue<EventWithSubscriber> queue =
24 Queues.newConcurrentLinkedQueue();
25
26 @Override
27 void dispatch(Object event, Iterator<Subscriber> subscribers) {
28 checkNotNull(event);
29 // 拆分后入队
30 while (subscribers.hasNext()) {
31 queue.add(new EventWithSubscriber(event, subscribers.next()));
32 }
33
34 EventWithSubscriber e;
35 while ((e = queue.poll()) != null) {
36 e.subscriber.dispatchEvent(e.event);
37 }
38 }
39
40 private static final class EventWithSubscriber {
41 private final Object event;
42 private final Subscriber subscriber;
43
44 private EventWithSubscriber(Object event, Subscriber subscriber) {
45 this.event = event;
46 this.subscriber = subscriber;
47 }
48 }
49 }
注意点:
1.eventbus默认使用的线程池MoreExecutors.directExecutor(),其execute方法是直接调用传入的runnable的run方法,是非异步的
2.使用AsyncEventBus时,请在对应的方法上添加@AllowConcurrenEvents
三.从并发安全的角度出发,对比下新老版本的注册流程
本部分为补充内容,重点探讨新老版本的注册并发安全问题,可略过
从20.0开始,event bus的注册程变成了上面分析的,那么之前的版本是如何实现的呢,一起来分析下.先切到16.0 的tag,注册代码如下
显然是使用了读写锁,不加锁,eventType会相互覆盖(HashMultiMap是非线程安全的),先给eventbus加个getSubscriberByType(),记得修改下EventSubscriber的修饰符为public,然后做个多线程的测试
1 /** 2 * @author tele 3 * @Description 4 * @create 2021-01-24 5 */ 6 public class ListenerA { 7 8 @Subscribe 9 public void handle(String msg) { 10 System.out.println("ListenerA:" + msg); 11 } 12 13 } 14 15 /** 16 * @author tele 17 * @Description 18 * @create 2021-01-24 19 */ 20 public class ListenerB { 21 22 @Subscribe 23 public void handle(String msg) { 24 System.out.println("ListenerB:" + msg); 25 } 26 27 } 28 29 /** 30 * @author tele 31 * @Description 32 * @create 2021-01-24 33 */ 34 public class Main { 35 36 37 public static void main(String[] args) throws InterruptedException { 38 39 final EventBus eventBus = new EventBus(); 40 final ListenerA a = new ListenerA(); 41 ListenerB b = new ListenerB(); 42 CountDownLatch countDownLatch = new CountDownLatch(6); 43 44 Runnable r1 = ()-> { 45 eventBus.register(a); 46 countDownLatch.countDown(); 47 }; 48 Thread t1 = new Thread(r1); 49 Thread t2 = new Thread(r1); 50 Thread t3 = new Thread(r1); 51 52 Runnable r2 = ()-> { 53 eventBus.register(b); 54 countDownLatch.countDown(); 55 }; 56 Thread t4 = new Thread(r2); 57 Thread t5 = new Thread(r2); 58 Thread t6 = new Thread(r2); 59 60 t1.start(); 61 t2.start(); 62 t3.start(); 63 t4.start(); 64 t5.start(); 65 t6.start(); 66 countDownLatch.await(); 67 SetMultimap<Class<?>, EventSubscriber> subscribersByType = eventBus.getSubscribersByType(); 68 subscribersByType.asMap().forEach((k,v)-> { 69 System.out.println("key:" + k); 70 v.forEach(System.out::println); 71 }); 72 } 73 }
输出结果如下:
ok,没啥问题,接下来再修改下源码把使用读写锁的两行代码注释掉,再执行下代码
输出结果如下:
显然,ListenerA的注册结果被覆盖了,这里简要说下原因,subscribersByType,k-v结构简略表示为 K-event.class ,value-Set<Listener.class>,我们知道java中的hashset不重复的特性是基于hashmap实现的.同样的,这里的SetMultiMap实际是用的HashMultiMap,翻翻源码就知道了,内部存储数据的容器是hashmap,那么这个问题就转换成了hashmap的线程安全问题了,hashmap多线程put hash相同的元素会产生丢失问题,多线程下同时put get有可能导致get 出null.了解到这我们就知道为什么要加锁了,使用读写锁的版本一直持续到19.0,从20.0开始从开始使用并发容器代替读写锁,因为对于eventbus而言始终是读远大于写,基于cow机制实现的CopyOnWriteArrayList在读写同时进行时通过延迟更新的策略不阻塞线程,对于event的处理 而言是可以接受的,因为本次event在post时没有分发到对应的subsriber,下次同类型的event触发就ok了,事实上,这种场景极少,因为从使用经历来看,一般是项目启动时就注册,分发都是需要处理逻辑时才会触发,不阻塞与每次都需要加解读锁相比,显然不阻塞的性能更好了.老版本的分发流程不再赘述,因为确实没啥好分析的了,如果你能看懂上面分析的新版本的dispatcher,当你看老版本的时候就会感觉很简单了
四.优势与缺陷
1.进程内使用,无法实现跨进程处理,需要跨进程传递消息,还是老老实实的用消息队列吧
2.和redis一样基于内存,天然的不可靠,redis好歹还有aof和rdb,可event bus没有任何持久化机制
3.个人对新版的Subscriber实现方式有点看法,没必须要把线程池参数传递给Subscriber,因为Subscriber只是被执行者,16.0的版本线程池参数是AsyncEventBus持有
4.优势:简单,开箱即用
五.小结
1.只分析了注册与分发流程,异常处理之类的没有涉及,用法的话,网上已经很多了,不再赘述
2.event bus的代码很巧妙,细细品味还有很多巧妙之处,比如上面那个dispatching变量
六.参考文档
1.github https://github.com/google/guava/wiki/EventBusExplained#for-producers
