This is the 13th day of my participation in the November Gwen Challenge. Check out the event details: The last Gwen Challenge 2021
Introduction to the
EventBus is the publish/subscribe EventBus for Android and Java. Uncoupling avoids callback hell and is simple and easy to use
Method of use
Define events
public static class MessageEvent { /* Additional fields if needed */ }
Copy the codeDefine subscription methods to handle received events
@Subscribe(threadMode = ThreadMode.MAIN)
public void onMessageEvent(MessageEvent event) {/* Do something */};
Copy the codeRegister and deregister activities and Fragments according to their life cycles.
@Override
public void onStart() {
super.onStart();
EventBus.getDefault().register(this);
}
@Override
public void onStop() {
super.onStop();
EventBus.getDefault().unregister(this);
}
Copy the codeSend the event
EventBus.getDefault().post(new MessageEvent());
Copy the codeThis section describes how EventBus works
The Subscribe annotations
@Subscribe(threadMode = ThreadMode.MAIN)
public void onMessageEvent(MessageEvent event){
Log.d("arrom",event.toString());
}
Copy the codeA concrete implementation of the Subscribe annotation
@Documented @Retention(RetentionPolicy.RUNTIME) @Target({ElementType.METHOD}) public @interface Subscribe { // POSTING ThreadMode ThreadMode () Default threadmode.posting; POSTING; POSTING; // Support sticky events, Boolean sticky() default false; Int priority() default 0; // Set the priority of the event subscription method. }Copy the codeThe threadMode attribute has the following optional values:
- Threadmode. POSTING is the default thread schema for POSTING events in one thread and processing events in the other thread.
- Threadmode. MAIN, such as sending events on the MAIN thread (UI thread), handles events directly on the MAIN thread; If an event is sent in a child thread, it is first queued and then switched to the main thread by Handler, which processes the event in turn.
- Threadmode. MAIN_ORDERED, regardless of which thread sends the event, queues the event first and then switches to the main thread via Handler, processing the event in turn.
- Threadmode. BACKGROUND, if an event is sent on the main thread, the event is queued and then processed through the thread pool. If an event is sent in a child thread, the event is processed directly in the thread that sent the event.
- Threadmode. ASYNC, regardless of which thread sends the event, enqueues it and processes it through the thread pool.
Register event
EventBus.getDefault().register(this);
Copy the codeGo to the getDefault method
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;
}
Copy the codeGetDefault () is a singleton method that guarantees that there is currently only one EventBus instance
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; }Copy the codeInitialization of related properties
private static final EventBusBuilder DEFAULT_BUILDER = new EventBusBuilder();
Copy the codeDEFAULT_BUILDER is the default EventBusBuilder.
We can also change the properties of EventBus by configuring EventBusBuilder.
EventBus.builder()
.eventInheritance(false)
.logSubscriberExceptions(false)
.build()
.register(this);
Copy the codeEnter the register method
Public void register(Object subscriber) {// Get the Class Object <? > subscriberClass = subscriber.getClass(); // SubscriberMethod Class SubscriberMethod Class SubscriberMethod Class SubscriberMethod Class // Method object, thread mode, event type, priority, stickiness, etc subscriberMethodFinder.findSubscriberMethods(subscriberClass); synchronized (this) { for (SubscriberMethod subscriberMethod : // Loop through the collection of methods subscribed to the event to subscribe(subscribe, subscriberMethod); }}}Copy the codeThe register() method is divided into two parts: lookup and registration.
To find the
List<SubscriberMethod> findSubscriberMethods(Class<? > subscriberClass) {// METHOD_CACHE is a ConcurrentHashMap that directly stores the collection of subscriberClass and corresponding SubscriberMethod to improve registration efficiency and assign values to repeated lookup. List<SubscriberMethod> subscriberMethods = METHOD_CACHE.get(subscriberClass); if (subscriberMethods ! = null) { return subscriberMethods; } // Since the default EventBusBuilder is used, the ignoreGeneratedIndex property defaults to false, That is whether to ignore the annotation generator if (ignoreGeneratedIndex) {subscriberMethods = findUsingReflection(subscriberClass); } else { subscriberMethods = findUsingInfo(subscriberClass); } // If there is no method in the corresponding class, Will throw an exception if (subscriberMethods isEmpty ()) {throw new EventBusException subscriberClass (" Subscriber "+ +" and its super classes have no public methods with the @Subscribe annotation"); } else {// A method to save found subscription events method_cache. put(subscriberClass, subscriberMethods); return subscriberMethods; }}Copy the codeThe findUsingInfo() method is called after the collection is cached. The findUsingInfo() method is called after the collection is cached.
private List<SubscriberMethod> findUsingInfo(Class<? > subscriberClass) { FindState findState = prepareFindState(); findState.initForSubscriber(subscriberClass); // Findstate. clazz is the 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 {/ / subscription via the reflection events of method findUsingReflectionInSingleClass (findState); } / / modify findState. Clazz for subscriberClass parent Class, which need to traverse the superclass findState. MoveToSuperclass (); } // The found methods are stored in the subscriberMethods collection of the FindState instance. Return getMethodsAndRelease(findState); return getMethodsAndRelease(findState); return getMethodsAndRelease(findState); }Copy the codeThe findUsingInfo() method looks for the method that subscribed to the event in the class currently being registered and its parent, and there is a FindState class that is an internal class to the SubscriberMethodFinder that AIDS in finding the method that subscribed to the event
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 methods = findState.clazz.getMethods(); findState.skipSuperClasses = true; } for (Method Method: methods) {int modiFIERS = method.getModifiers(); Public if ((modifiers & Modifier. Public)! = 0 && (modifiers & MODIFIERS_IGNORE) == 0) {// Get the type of all the arguments to the current method Class<? >[] parameterTypes = method.getParameterTypes(); // If (parametertypes. length == 1) {Subscribe subscribeAnnotation = method.getannotation (Subscribe. Class); // Subscribe if (Subscribe! = null) {// Get the type of this parameter Class<? > eventType = parameterTypes[0]; The checkAdd() method is used to check whether the FindState anyMethodByEventType map has been added with the current eventType as the key pair. Return true if (findState.checkAdd(method, eventType)) {Subscribe threadMode attribute, The thread pattern ThreadMode ThreadMode = subscribeAnnotation. ThreadMode (); // Create a SubscriberMethod object, And added to the collection subscriberMethods 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"); }}}Copy the codeIt looks for methods to subscribe to events primarily through reflection. The findSubscriberMethods() process in this Register () method completes the analysis, and we have found the collection of methods that subscribe to events in the currently registered class and its parent class
registered
Private void subscribe(Object subscriber, SubscriberMethod SubscriberMethod) {// Get the parameter type of the method currently subscribed to the event Class<? > eventType = subscriberMethod.eventType; // The Subscription class holds the class object to be registered and the current subscriberMethod Subscription newSubscription = newSubscription (subscriber, subscriberMethod); SubscriptionsByEventType is a HashMap, // subscriptionsByEventType = subscriptionsByEventType; // subscriptionsByEventType = subscriptionsByEventType CopyOnWriteArrayList<Subscription> subscriptions = subscriptionsByEventType.get(eventType); // If it does not exist, create a SUBSCRIPTIONS, And save to subscriptionsByEventType 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); } // Add newSubscription object to subscriptions int size = subscription.size (); for (int i = 0; i <= size; i++) { if (i == size || subscriberMethod.priority > subscriptions.get(i).subscriberMethod.priority) { subscriptions.add(i, newSubscription); break; }} // typesBySubscribere is a HashMap that stores a key pair of the Class to be registered and a set of parameter types of the methods that subscribe to events in the registered Class. >> subscribedEvents = typesBySubscriber.get(subscriber); // Create a subscribedEvents and save it to typesBySubscriber if (subscribedEvents == null) {subscribedEvents = new ArrayList<>(); typesBySubscriber.put(subscriber, subscribedEvents); } // Save the parameter type of the method that is currently subscribed to the event subscribedevents.add (eventType); If (subscriberMethod.sticky) {if (eventInheritance) {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); }}}Copy the codeSubscribe () gets two hashmaps: subscriptionsByEventType and typesBySubscriber. Among them, subscriptionsByEventType is used when sending events to complete the processing of events. When canceling EventBus registration, typesBySubscriber and subscriptionsByEventType are used to release related resources.
Cancel the registration
Public synchronized void unregister(Object subscriber) {List<Class<? >> subscribedTypes = typesBySubscriber.get(subscriber); if (subscribedTypes ! = null) {// Iterate over the set of parameter types, freeing the Subscription for (Class<? > eventType : subscribedTypes) { unsubscribeByEventType(subscriber, eventType); } // Delete the pair of typesbysubscriber.remove (subscriber); } else { logger.log(Level.WARNING, "Subscriber to unregister was not registered before: " + subscriber.getClass()); }}Copy the codeThe unsubscribeByEventType() method is called
private void unsubscribeByEventType(Object subscriber, Class<? > eventType) {/ / get the current parameter types corresponding collection Subscription List < Subscription > subscriptions = subscriptionsByEventType. Get (eventType); if (subscriptions ! = null) { int size = subscriptions.size(); // Subscription set for (int I = 0; i < size; i++) { Subscription subscription = subscriptions.get(i); // If the current subscription object corresponds to the same registered class object as the unregistered class object, If (subscription == subscriber) {subscription. Active = false; subscriptions.remove(i); i--; size--; }}}}Copy the codeIn the unregister() method, the main thing is to release the resources cached in typesBySubscriber and subscriptionsByEventType.
Send the event
Public void post (Object event) {/ / currentPostingThreadState is a ThreadLocal PostingThreadState type / / PostingThreadState class information such as thread and preserved the event queue model PostingThreadState postingState = currentPostingThreadState. The get (); List<Object> eventQueue = postingState.eventQueue; // Add events to the event queue eventqueue.add (event); // isPosting defaults to false if (! Whether postingState. IsPosting) {/ / give priority to the thread postingState. IsMainThread = isMainThread (); postingState.isPosting = true; if (postingState.canceled) { throw new EventBusException("Internal error. Abort state was not reset"); } try {// traverse the event queue while (! Eventqueue.isempty ()) {// Send a single event // eventQueue.remove(0), remove event postSingleEvent(eventQueue.remove(0), postingState); } } finally { postingState.isPosting = false; postingState.isMainThread = false; }}}Copy the codeThe POST () method saves the sent event to the event queue of the List, and then loops it out of the queue to the postSingleEvent() method for processing.
private void postSingleEvent(Object event, PostingThreadState postingState) throws Error { Class<? > eventClass = event.getClass(); boolean subscriptionFound = false; If (eventInheritance) {// Search for the Class of the current event type and save it with the Class of the current event type into the collection 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); } if (sendNoSubscriberEvent && eventClass ! = NoSubscriberEvent.class && eventClass ! = SubscriberExceptionEvent.class) { post(new NoSubscriberEvent(this, event)); }}}Copy the codePostSingleEvent () method, according to the eventInheritance properties, decide whether to traverse upward parent types of events, and then use postSingleEventForEventType further processing events () method.
private boolean postSingleEventForEventType(Object event, PostingThreadState postingState, Class<? > eventClass) { CopyOnWriteArrayList<Subscription> subscriptions; Synchronized (this) {/ / to get event types corresponding to the Subscription set subscriptions = subscriptionsByEventType. Get (eventClass); } // If (subscriptions! = null && ! Subscription.isempty ()) {for (Subscription Subscription: subscriptions) {// Record events postingstate.event = event; / / record the corresponding subscription postingState. Subscription = subscription; boolean aborted = false; Try {/ / final event handling 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; }Copy the codePostSingleEventForEventType () method of the core is the event type corresponding traversal send the Subscription set, and then call postToSubscription process events () method.
Handle events
private void postToSubscription(Subscription subscription, Object event, Boolean isMainThread) {/ / determine the subscription event method thread mode switch (subscription. SubscriberMethod. ThreadMode) {/ / the default mode of thread, Case POSTING: invokeSubscriber(subscription, event); break; If (isMainThread) {invokeSubscriber(subscription, event); } else {// If the event is sent in the child thread, the event is queued, // mainThreadPoster is not null mainThreadPoster. Enqueue (subscription, event); } break; // Regardless of which thread sends the event, the event is first queued and then switched to the main thread by Handler, which processes the event in turn. // mainThreadPoster not empty case MAIN_ORDERED: if (mainThreadPoster! = null) { mainThreadPoster.enqueue(subscription, event); } else { invokeSubscriber(subscription, event); } break; case BACKGROUND: If (isMainThread) {backgroundPoster. Enqueue (subscription, event); // If (isMainThread) {backgroundPoster. } else {// If an event is sent in a child thread, invokeSubscriber is handled by reflection directly in the sending thread (subscription, event); } break; // Regardless of which thread sends the event, the event is queued and processed by the thread pool. case ASYNC: asyncPoster.enqueue(subscription, event); break; default: throw new IllegalStateException("Unknown thread mode: " + subscription.subscriberMethod.threadMode); }}Copy the codeThe postToSubscription() method determines how an event is handled based on the pattern of the thread that subscribes to the event method and the thread that sent the event. There are two main ways to handle the event: One way is to use reflection to execute subscribed events directly in the corresponding thread through the invokeSubscriber() method, so that sent events are received by the subscriber and processed accordingly.
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); }}Copy the codeIf an event is sent in a child thread, the event is handled directly by reflection in the thread that sent the event
MainThreadPoster. Enqueue (subscription, event) ¶ mainThreadPoster. Enqueue (mainThreadPoster. MainThreadPoster is an instance of the HandlerPoster class.
public class HandlerPoster extends Handler implements Poster { private final PendingPostQueue queue; private boolean handlerActive; . public void enqueue(Subscription subscription, PendingPost PendingPost = PendingPost.obtainPendingPost(subscription, event); Synchronized (this) {queue. Enqueue (pendingPost); if (! handlerActive) { handlerActive = true; The handleMessage() method is executed, completing the switch from child thread to main thread. If (! sendMessage(obtainMessage())) { throw new EventBusException("Could not send handler message"); } } } } @Override public void handleMessage(Message msg) { boolean rescheduled = false; try { long started = SystemClock.uptimeMillis(); PendingPost PendingPost = queue.poll(); PendingPost = queue.poll(); . / / further processing pendingPost eventBus. InvokeSubscriber (pendingPost); . } } finally { handlerActive = rescheduled; }}}Copy the codeThe enqueue() method for HandlerPoster encapsulates the subscription and event objects into a PendingPost object, which is stored in a queue and then switched to the main thread by a Handler. The PendingPost object is looped out of the queue in the handleMessage() method and handed over to the invokeSubscriber() method for further processing.
void invokeSubscriber(PendingPost pendingPost) { Object event = pendingPost.event; Subscription subscription = pendingPost.subscription; / / release pendingPost reference resources pendingPost. ReleasePendingPost (pendingPost); If (subscription. Active) {invokeSubscriber(subscription, event); }}Copy the codeFetching previously saved events from The pendingPost, subscription, and then using reflection to execute the subscription is back to the first approach. So the core of mainThreadposter.enqueue (subscription, event) is to queue the event and then switch it from the child thread to the main thread by a Handler.
Backgroundposter.enqueue () and asyncposter.enqueue are similar in that events are enqueued and then unqueued internally, but further processed through the thread pool.
Viscous event
Typically, we use EventBus to prepare to subscribe to events, then register the events, and finally send the events, that is, have the recipient of the event first. Sticky events, on the other hand, can be sent first, followed by methods for subscribing to events and registering events.
EventBus.getDefault().postSticky(event);
Copy the codeEnter postSticky source code
public void postSticky(Object event) {
synchronized (stickyEvents) {
stickyEvents.put(event.getClass(), event);
}
post(event);
}
Copy the codeThe ostSticky() method does two main things:
- First, save the event type and corresponding event to stickyEvents for subsequent use;
- It then executes post(event) to continue sending the event, which is the same post() method that was sent earlier.
Therefore, if there is a subscriber of the corresponding type of event before sending the sticky event, it can still receive the sent sticky event even if it is non-sticky.
Registration of sticky events
private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) { ...... . . // If (Subscribe method.sticky) {// If (Subscribe method.sticky) {// Default is true, If (eventInheritance) {// stickyEvents save the event type and the corresponding event when sending a sticky event Set< map.Entry <Class<? >, Object>> entries = stickyEvents.entrySet(); for (Map.Entry<Class<? >, Object> entry : entries) { Class<? > candidateEventType = entry.getKey(); / / if candidateEventType is a subclass of eventType or if (eventType. IsAssignableFrom (candidateEventType)) {/ / get the corresponding event Object stickyEvent = entry.getValue(); / / handling viscous checkPostStickyEventToSubscription (newSubscription stickyEvent); } } } else { Object stickyEvent = stickyEvents.get(eventType); checkPostStickyEventToSubscription(newSubscription, stickyEvent); }}}Copy the codeStickyEvents are handled by iterating through stickyEvents during EventBus registration. If the currently registered event subscription method is stickyEvents and receives an event of the same type as one of the stickyEvents or its parent class, Extract the specific event of the corresponding event type in stickyEvents for further processing.
private void checkPostStickyEventToSubscription(Subscription newSubscription, Object stickyEvent) {
if (stickyEvent != null) {
postToSubscription(newSubscription, stickyEvent, isMainThread());
}
}
Copy the codeThe subscribe () method is the core of checkPostStickyEventToSubscription () method.
Index of the Subscriber
EventBus is mainly used to find subscription event method information through reflection at project runtime. If there are a large number of subscription event methods in a project, the performance of the project runtime will be affected. In addition to finding subscription event method information by reflection at project runtime, EventBus also provides a way to find subscription event method information by annotation handler at project compile time, generating a secondary Index class called Subscriber Index to hold this information. The principle is similar to ButterKnife.
We need to add dependencies to the configuration file
// annotationProcessor 'org. greenRobot :eventbus-annotation-processor:3.2.0'Copy the codeAdd the configuration to the Application as well
EventBus.builder().addIndex(new MyEventBusIndex()).installDefaultEventBus();
Copy the codeEnter the MyEventBusIndex class
Public class MyEventBusIndex implements SubscriberInfoIndex {// Saves the class type of the currently registered class and information about the event subscription method in it Map<Class<? >,SubscriberInfo> SUBSCRIBER_INDEX; static { SUBSCRIBER_INDEX = new HashMap<>(); putIndex(new SimpleSubscriberInfo(MainActivity.class,true, new SubscriberMethodInfo[]{ new SubscriberMethodInfo("changeText",String.class), })); } private static void putIndex(SubscriberInfo info){ SUBSCRIBER_INDEX.put(info.getSubscriberClass(),info); } @Override public SubscriberInfo getSubscriberInfo(Class<? > subscriberClass) { SubscriberInfo info = SUBSCRIBER_INDEX.get(subscriberClass); if(null! =info){ return info; } return null; }}Copy the codeGo to the addIndex method
public EventBusBuilder addIndex(SubscriberInfoIndex index) {
if (subscriberInfoIndexes == null) {
subscriberInfoIndexes = new ArrayList<>();
}
subscriberInfoIndexes.add(index);
return this;
}
Copy the codeSave instances of the generated index classes in the subscriberInfoIndexes collection.
public EventBus installDefaultEventBus() {
synchronized (EventBus.class) {
if (EventBus.defaultInstance != null) {
throw new EventBusException("Default instance already exists." +
" It may be only set once before it's used the first time to ensure consistent behavior.");
}
EventBus.defaultInstance = build();
return EventBus.defaultInstance;
}
}
Copy the codeCreate an EventBus instance with the current EventBusBuilder object, so that the Subscriber Index we configured through EventBusBuilder is passed to the EventBus instance. It then assigns to the defaultInstance member variable of EventBus.
The default singleton for EventBus is generated in the Application, ensuring that eventbus.getDefault () is executed elsewhere in the project to get a unique EventBus instance
Because we now use the Subscriber Index so not through findUsingReflectionInSingleClass () to reflect parsing subscribe to events.
Private SubscriberInfo getSubscriberInfo(FindState FindState) {// This condition is not valid if (FindState. = null && findState.subscriberInfo.getSuperSubscriberInfo() ! = null) { SubscriberInfo superclassInfo = findState.subscriberInfo.getSuperSubscriberInfo(); if (findState.clazz == superclassInfo.getSubscriberClass()) { return superclassInfo; If (subscriberInfoIndexes! = null) {// SubscriberInfoIndex index: // Find SubscriberInfo info = based on the Class Class of the registered Class index.getSubscriberInfo(findState.clazz); if (info ! = null) { return info; } } } return null; }Copy the codeThe subscriberInfoIndexes are created in the addIndex() method that stores the index class instance in the project, that is, MyEventBusIndex. Continue with the getSubscriberInfo() method of the index class. We’re in the MyEventBusIndex class.
@Override public SubscriberInfo getSubscriberInfo(Class<? > subscriberClass) { SubscriberInfo info = SUBSCRIBER_INDEX.get(subscriberClass); if(null! =info){ return info; } return null; }Copy the codeFind the corresponding SubscriberInfo from SUBSCRIBER_INDEX according to the Class type of the registered Class. If we define a method to subscribe to events in the registered Class, the info is not empty. Findstate.subscriberinfo! = null, the main content of the analysis is finished, the other as before the registration process.
The core of Subscriber Index is to use annotation processor to generate Index class to save event subscription method information when the project is compiled, and then set the Index class instance to EventBus when the project is running, so that when registering EventBus, the event subscription method information corresponding to the current registered class can be taken out from the Index class. To complete the final registration, the runtime reflection process is avoided, so there is a qualitative improvement in performance.
EventBus thread switch
The method in question is EventBus’s postToSubscription() method
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);
}
}
Copy the codeSwitch to the main thread to receive events
To receive messages on the MAIN thread, set threadMode to MAIN
case MAIN:
if (isMainThread) {
invokeSubscriber(subscription, event);
} else {
mainThreadPoster.enqueue(subscription, event);
}
Copy the codeIf it is a non-main thread, it is handled in mainThreadPoster
mainThreadPoster = mainThreadSupport ! = null ? mainThreadSupport.createPoster(this) : null;Copy the codeGo to the createPoster method
public interface MainThreadSupport { boolean isMainThread(); Poster createPoster(EventBus eventBus); class AndroidHandlerMainThreadSupport implements MainThreadSupport { private final Looper looper; public AndroidHandlerMainThreadSupport(Looper looper) { this.looper = looper; } @Override public boolean isMainThread() { return looper == Looper.myLooper(); } @Override public Poster createPoster(EventBus eventBus) { return new HandlerPoster(eventBus, looper, 10); }}}Copy the codeThe logic is all in the HandlerPoster class, which implements the Poster interface, which is a normal Handler, except that its Looper uses the Main Looper of the Main thread to distribute messages to the Main thread.
public void handleMessage(Message msg) { boolean rescheduled = false; try { long started = SystemClock.uptimeMillis(); while (true) { PendingPost pendingPost = queue.poll(); if (pendingPost == null) { synchronized (this) { // Check again, this time in synchronized pendingPost = queue.poll(); if (pendingPost == null) { handlerActive = false; return; } } } eventBus.invokeSubscriber(pendingPost); Long timeInMethod = systemclock. uptimeMillis() - started; if (timeInMethod >= maxMillisInsideHandleMessage) { if (! sendMessage(obtainMessage())) { throw new EventBusException("Could not send handler message"); } rescheduled = true; return; } } } finally { handlerActive = rescheduled; }}Copy the codeTo avoid frequently sending sendMessage() to the main thread, EventBus’s practice is to process as many message events as possible in a message, so it uses a while loop to continuously fetch messages from the message queue.
At the same time in order to avoid long-term occupied the main thread, interval of 10 ms (maxMillisInsideHandleMessage = 10 ms) will resend sendMessage (), is used to make the main thread of the executive power, avoid to cause the UI caton and ANR.
MAIN ensures that the event is received. In the MAIN thread, it is important to note that if the event is sent in the MAIN thread, it will execute directly using MAIN. To make development and configurability even better, MAIN_ORDERED was added to EventBus V3.1.1, which does not discriminate between current threads, but instead uses mainThreadPoster for all message distribution that must go through the Handler.
Switch to child thread execution
To allow messages to be processed in child threads, you can set threadMode to BACKGROUND or AYSNC, both of which can be implemented, but there are some differences.
BACKGROUND
case BACKGROUND:
if (isMainThread) {
backgroundPoster.enqueue(subscription, event);
} else {
invokeSubscriber(subscription, event);
}
break;
Copy the codeBACKGROUND will distinguish between the thread on which the event is currently occurring, whether it is the main thread, and non-main thread which will distribute the event directly, and backgroundPoster which will distribute the event if it is the main thread
private volatile boolean executorRunning; BackgroundPoster(EventBus eventBus) { this.eventBus = eventBus; queue = new PendingPostQueue(); } public void enqueue(Subscription subscription, Object event) { PendingPost pendingPost = PendingPost.obtainPendingPost(subscription, event); synchronized (this) { queue.enqueue(pendingPost); if (! executorRunning) { executorRunning = true; eventBus.getExecutorService().execute(this); }}}Copy the codeBackgroundPoster also implements the Poster interface, which also maintains a linked list implementation of the message queue PendingPostQueue.
In BackgroundPoster, this is done using EventBus’s executorService thread pool object
Private volatile Boolean executorRunning; private volatile Boolean executorRunning; BackgroundPoster(EventBus eventBus) { this.eventBus = eventBus; queue = new PendingPostQueue(); } public void enqueue(Subscription subscription, Object event) { PendingPost pendingPost = PendingPost.obtainPendingPost(subscription, event); synchronized (this) { queue.enqueue(pendingPost); // Execute if (! executorRunning) { executorRunning = true; eventBus.getExecutorService().execute(this); } } } @Override public void run() { try { try { while (true) { PendingPost pendingPost = queue.poll(1000); if (pendingPost == null) { synchronized (this) { // Check again, this time in synchronized pendingPost = queue.poll(); if (pendingPost == null) { executorRunning = false; return; } } } eventBus.invokeSubscriber(pendingPost); } } catch (InterruptedException e) { eventBus.getLogger().log(Level.WARNING, Thread.currentThread().getName() + " was interruppted", e); } } finally { executorRunning = false; }}Copy the codeIn BackgroundPoster, when processing an event thrown by the main thread, there’s only one thread at a time that’s going to loop in and fetch the event processing event from the queue.
Synchronized synchronization was used to ensure thread-safety of queue data, and volatile identification was used to keep execution status visible from different threads
ASYNC
asyncPoster.enqueue(subscription, event); class AsyncPoster implements Runnable, Poster { ... public void enqueue(Subscription subscription, Object event) { PendingPost pendingPost = PendingPost.obtainPendingPost(subscription, event); queue.enqueue(pendingPost); eventBus.getExecutorService().execute(this); } @Override public void run() { PendingPost pendingPost = queue.poll(); if(pendingPost == null) { throw new IllegalStateException("No pending post available"); } eventBus.invokeSubscriber(pendingPost); }}Copy the codeThe corresponding Poster is AsyncPoster, which does no special processing, and all events are brainlessly thrown to the executorService thread pool of EventBus, which ensures that the thread that causes the event, and the thread that receives the event, It must be different, and it is guaranteed that events are handled in child threads.
BACKGROUND and ASYNC are both guaranteed to receive processing events in child threads, but their internal implementations are different
BACKGROUND only uses one child thread at a time to loop events from the event queue and process them. That is, the execution efficiency of previous events affects the execution of subsequent events.
ASYNC mindlessly sends tasks to the thread pool executorService, which, if you don’t configure it, by default uses Executors’ newCachedThreadPool(). OOM appears when there are too many tasks (events).