关键词：
EvenBus 可以在不同模块间传递信息，减少接口的使用。
一、使用例子
<span style="font-size:18px;">public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
EventBus.getDefault().register(this);
testEventBus();
}
@Subscribe(threadMode = ThreadMode.MAIN)
public void getData(String result){
Toast.makeText(MainActivity.this, result, Toast.LENGTH_SHORT).show();
}
private void testEventBus(){
new Thread(new Runnable() {
@Override
public void run() {
try {
Thread.sleep(5 * 1000);
EventBus.getDefault().post("这是 EventBus 的测试");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}).start();
}
@Override
protected void onDestroy() {
super.onDestroy();
EventBus.getDefault().unregister(this);
}
}</span>
二、注册
EventBus.getDefault().regiser(this);
EventBus 负责对外提供 API .
（1）getDefault() 获得 EventBus 实例，使用了 volatile 和 单例模式
<span style="font-size:18px;"> static volatile EventBus defaultInstance;
/** Convenience singleton for apps using a process-wide EventBus instance. */
public static EventBus getDefault() {
if (defaultInstance == null) {
synchronized (EventBus.class) {
if (defaultInstance == null) {
defaultInstance = new EventBus();
}
}
}
return defaultInstance;
}</span>
new EventBus() 构建对象的时候，使用了 Builder 模式
<span style="font-size:14px;"> public EventBus() {
this(DEFAULT_BUILDER);
}
EventBus(EventBusBuilder builder) {
subscriptionsByEventType = new HashMap<>();
typesBySubscriber = new HashMap<>();
stickyEvents = new ConcurrentHashMap<>();
mainThreadPoster = new HandlerPoster(this, Looper.getMainLooper(), 10); // 一个主线程的 Handler
backgroundPoster = new BackgroundPoster(this); // Runnable
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;
}</span>（2） register(Object subscriber) 过程
EventBus 有几个重要的成员变量，在我们进行流程分析前，先看看
private final Map<Class<?>, CopyOnWriteArrayList<Subscription>> subscriptionsByEventType;
private final Map<Object, List<Class<?>>> typesBySubscriber;
private final ThreadLocal<PostingThreadState> currentPostingThreadState = new ThreadLocal<PostingThreadState>() {
@Override
protected PostingThreadState initialValue() {
return new PostingThreadState();
}
};subscripitonsByEventType 和 typesBySubcriber 都是 HashMap, 在上面构建新的 EventBus 对象时初始化。
其中 subcriptionsByEventType 是以eventType 为 key ，Subcription 列表为 value; 而 typesBySubcriber 是以 订阅者 subcriber 为 key, 订阅事件 SubcribedEvents 列表为 value 的。
Subcription 类有三个成员变量
final Object subscriber;
final SubscriberMethod subscriberMethod;
/**
* Becomes false as soon as {@link EventBus#unregister(Object)} is called, which is checked by queued event delivery
* {@link EventBus#invokeSubscriber(PendingPost)} to prevent race conditions.
*/
volatile boolean active;其中 subcriber 与 typesBySubcriber 中的 key 联系起来。
currentPostingThreadState 是一个 ThreadLocal ，存放 PostingThreadState , 用于监听整个post 过程，关于 ThreadLocal 的详细内容，可去看任玉刚的《Android 开发探索艺术》一书。
下面是注册的整个大概流程：
主线：
在 EventBus.java 中
public void register(Object subscriber) {
// 返回一个 Class 类型的实例
Class<?> subscriberClass = subscriber.getClass(); // 例如 com.yxhuang.mytestapplication.MainActivity
// 获取订阅的方法， 内部最终时通过注解是方式获得订阅的方法
List<SubscriberMethod> subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);
synchronized (this) {
for (SubscriberMethod subscriberMethod : subscriberMethods) {
subscribe(subscriber, 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<Subscription> subscriptions = subscriptionsByEventType.get(eventType);
if (subscriptions == null) {
subscriptions = new CopyOnWriteArrayList<>();
// 添加到 subscriptionsByEventType
subscriptionsByEventType.put(eventType, subscriptions);
} else {
// 如果已经注册过，则抛出异样，防止重复注册
if (subscriptions.contains(newSubscription)) {
throw new EventBusException("Subscriber " + subscriber.getClass() + " already registered to event " + eventType);
}
}
// 根据优先级添加到 CopyOnWriteArrayList 中
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;
}
}
// 添加到 Map<Object, List<Class<?>>> typesBySubscriber
List<Class<?>> subscribedEvents = typesBySubscriber.get(subscriber);
if (subscribedEvents == null) {
subscribedEvents = new ArrayList<>();
typesBySubscriber.put(subscriber, subscribedEvents);
}
subscribedEvents.add(eventType);
if (subscriberMethod.sticky) { // 是否为粘性方法
if (eventInheritance) { // 默认是 false
// 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>).
Set<Map.Entry<Class<?>, Object>> entries = stickyEvents.entrySet();
for (Map.Entry<Class<?>, Object> entry : entries) {
Class<?> candidateEventType = entry.getKey();
// When using instanceof, you need to know the class of "B" at compile time. When using isAssignableFrom()
// it can be dynamic and change during runtime.
if (eventType.isAssignableFrom(candidateEventType)) {
Object stickyEvent = entry.getValue();
checkPostStickyEventToSubscription(newSubscription, stickyEvent);
}
}
} else {
Object stickyEvent = stickyEvents.get(eventType);
checkPostStickyEventToSubscription(newSubscription, stickyEvent);
}
}
}整体的过程还是比较简洁的
1、以 subcriber 的 class 作为 key , 传进 subcriberMethodFinder.findSubcriMethods( ...) 方法中，并得到一个所有订阅方法的 list;
2、调用 subcribe () 方法，将所有的订阅方法相应放到 subcriptionsByEventType 和 typesByScriber 中，如果是粘性订阅方法，则进行相应的处理。
粘性方法的处理， 最终都会调用 checkPostStickEventToSubcriptions(...) 方法
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.
// 根据不同的 ThreadMode 进行分发
postToSubscription(newSubscription, stickyEvent, Looper.getMainLooper() == Looper.myLooper());
}
}在这个方法里面最后调用了 postToSubcription(...) 方法，分发相应的订阅结果，我们在后面的 post 过程中有分析。可见如果订阅方法是粘性的，则不需要调用 EventBus.post(...) 方法，在注册之后，就会自行分发结果。
我们再来看看注册过程是如何得到所有订阅方法的。
从 subcriberMethodFinder.findSucriberMethod(...) 进去
在 SucriberMethodFinder 类中
// 是否忽略生成的 index
private final boolean ignoreGeneratedIndex;
// 订阅缓存池
private static final Map<Class<?>, List<SubscriberMethod>> METHOD_CACHE = new ConcurrentHashMap<>();
// FindState 缓存池
private static final int POOL_SIZE = 4;
private static final FindState[] FIND_STATE_POOL = new FindState[POOL_SIZE];其中， FindState 类在查找订阅方法过程中使用
SucriberMethodFinder.findSucriberMethod(...)
List<SubscriberMethod> findSubscriberMethods(Class<?> subscriberClass) {
// 先从缓存中获取, METHOD_CACHE 是一个 CurrentHashMap
List<SubscriberMethod> subscriberMethods = METHOD_CACHE.get(subscriberClass);
if (subscriberMethods != null) {
return subscriberMethods;
}
if (ignoreGeneratedIndex) { // 是否忽略生成的 index 默认是 false
// 使用反射获取单个类里面的订阅方法
subscriberMethods = findUsingReflection(subscriberClass);
} else {
subscriberMethods = findUsingInfo(subscriberClass);
}
if (subscriberMethods.isEmpty()) {
throw new EventBusException("Subscriber " + subscriberClass
+ " and its super classes have no public methods with the @Subscribe annotation");
} else {
// 放入缓存中并返回
METHOD_CACHE.put(subscriberClass, subscriberMethods);
return subscriberMethods;
}
}2、将查找的订阅方法放进缓存中，并返回；
private List<SubscriberMethod> findUsingInfo(Class<?> subscriberClass) {
FindState findState = prepareFindState();
findState.initForSubscriber(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 {
// 利用反射查找自身的订阅方法
findUsingReflectionInSingleClass(findState);
}
// 查找父类的订阅方法
findState.moveToSuperclass();
}
// 返回所有的订阅方法，并释放掉 findState
return getMethodsAndRelease(findState);
}获取订阅者的信息
private SubscriberInfo getSubscriberInfo(FindState findState) {
// 获取父类订阅者的信息
if (findState.subscriberInfo != null && findState.subscriberInfo.getSuperSubscriberInfo() != null) {
SubscriberInfo superclassInfo = findState.subscriberInfo.getSuperSubscriberInfo();
if (findState.clazz == superclassInfo.getSubscriberClass()) {
return superclassInfo;
}
}
// 默认是空的，是由使用了索引时，才会调用
if (subscriberInfoIndexes != null) {
for (SubscriberInfoIndex index : subscriberInfoIndexes) {
SubscriberInfo info = index.getSubscriberInfo(findState.clazz);
if (info != null) {
return info;
}
}
}
return null;
}1. 调用 getSubcriberInfo(...) 方法获取订阅者的信息；
2. 调用 findUsingRelectionInSingleClass(...) ，用反射方法获得订阅方法；
3. 查找父类的订阅方法；
4. 释放掉 findState 并返回订阅方法；
这里我们重点看一下 FindState 和 如何利用反射得到订阅方法。先看 FindState
prepareFindState() 要和 getMethodsAndRelease() 方法一起看
private FindState prepareFindState() {
synchronized (FIND_STATE_POOL) {
for (int i = 0; i < POOL_SIZE; i++) {
FindState state = FIND_STATE_POOL[i];
if (state != null) {
FIND_STATE_POOL[i] = null;
return state;
}
}
}
return new FindState();
}
private List<SubscriberMethod> getMethodsAndRelease(FindState findState) {
List<SubscriberMethod> subscriberMethods = new ArrayList<>(findState.subscriberMethods);
findState.recycle();
synchronized (FIND_STATE_POOL) {
for (int i = 0; i < POOL_SIZE; i++) {
if (FIND_STATE_POOL[i] == null) {
FIND_STATE_POOL[i] = findState;
break;
}
}
}
return subscriberMethods;
}
FIND_STATE_POOL 是一个存有四个 FindState 对象的缓存池；
在 prepareFindState() 方法中，从 FIND_STATE_POOL 缓存池中取出一个 findState 对象并用一个 null 替代它在缓存池中的位置，然后将调用 FindState.initForSubcriber(..) 初始化 findState ； 在 getMethodsAndRelease(...) 方法中，将 findState 对象 recycle() 进行处理，然后查看 FIND_STATE_POOL 缓存池中那个位置为空，让后将这个处理后的 findState 放回缓存池中。
这样整个过程实现对 findState 对象的充分利用，减小因为频繁生成太多对象而占用太多的内存。
SubcriberMethodFinder.findUsingRelectionInSingleClass(...) 方法
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) {
// 返回一个用于描述构造器，方法或域的修饰符的整型数值。使用 Modifiers 类中的这个方法可以分析这个返回值。
int modifiers = method.getModifiers();
if ((modifiers & Modifier.PUBLIC) != 0 && (modifiers & MODIFIERS_IGNORE) == 0) {
// 返回一个用于描述参数类型的 Class 对象数组 （返回方法的参数）
Class<?>[] parameterTypes = method.getParameterTypes();
if (parameterTypes.length == 1) {
// 获得给定类型的注解，如果没有这样的注解，则返回 null
Subscribe subscribeAnnotation = method.getAnnotation(Subscribe.class);
if (subscribeAnnotation != null) {
Class<?> eventType = parameterTypes[0];
if (findState.checkAdd(method, eventType)) {
// 获得 ThreadMod 类型
ThreadMode threadMode = subscribeAnnotation.threadMode();
// 生成一个 SubscriberMethod 对象，放到列表中
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)) {
// 方法不是 public 则抛出异样
String methodName = method.getDeclaringClass().getName() + "." + method.getName();
throw new EventBusException(methodName +
" is a illegal @Subscribe method: must be public, non-static, and non-abstract");
}
}
}1、Class.getDeclaredMethod() 而不是 getMethod() 方法，是因为 getDeclaredMethod() 只放回自身和接口的方法，而 getMethod() 不仅返回自身的方法而且还返回从父类的继承而来的公有方法，这样使用 getDeclaredMethod() 可以节约获取方法的时间；
2、我们在设置订阅方法时使用了 Subcribe 注解类，并设置了 ThreadMode 类型
例子：
@Subscribe(threadMode = ThreadMode.MAIN)
public void getData(String result){
Toast.makeText(MainActivity.this, result, Toast.LENGTH_SHORT).show();
}
<span style="font-size:18px;">// 获得给定类型的注解，如果没有这样的注解，则返回 null
Subscribe subscribeAnnotation = method.getAnnotation(Subscribe.class);</span>
3、在获取 ThreadMode 之后，放到 findState 对象成员变量的列表中。
至此，整个注册过程基本上完成了。
三、Post 消息过程
在整个 post 过程中使用了 PostingThreadState 辅助类
/** For ThreadLocal, much faster to set (and get multiple values). */
final static class PostingThreadState {
// 存放 postEvent 事件列表
final List<Object> eventQueue = new ArrayList<Object>();
boolean isPosting; // 是否处于 posting 状态
boolean isMainThread; // 是否为主线程
Subscription subscription; // 订阅信息
Object event;
boolean canceled; // 是否被取消
}EventBus.post(...) 方法
public void post(Object event) {
// 中 ThreadLocal 中获取一个 PostingThreadState, 使用 ThreadLocal 传递对象，对整个 post 过程传递数据，不受不同线程的影响
PostingThreadState postingState = currentPostingThreadState.get(); // currentPostingThreadState 是 ThreadLocal
List<Object> eventQueue = postingState.eventQueue; // ArrayList<>;
eventQueue.add(event); // 添加到列表中
if (!postingState.isPosting) {
// 是否为主线程
postingState.isMainThread = Looper.getMainLooper() == Looper.myLooper();
// post 的状态
postingState.isPosting = true;
if (postingState.canceled) {
throw new EventBusException("Internal error. Abort state was not reset");
}
try {
while (!eventQueue.isEmpty()) {
// post 一个 event 事件
postSingleEvent(eventQueue.remove(0), postingState);
}
} finally {
postingState.isPosting = false;
postingState.isMainThread = false;
}
}
}2、从队列中取出一个 event 并调用 postSingleEvent(...) 方法，将 event 分发出去；
private void postSingleEvent(Object event, PostingThreadState postingState) throws Error {
Class<?> eventClass = event.getClass();
boolean subscriptionFound = false;
if (eventInheritance) { // 默认是 false，开启索引之后才会调用
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 {
// post 出去
subscriptionFound = postSingleEventForEventType(event, postingState, eventClass);
}
// 如果没有订阅者
if (!subscriptionFound) {
if (logNoSubscriberMessages) {
Log.d(TAG, "No subscribers registered for event " + eventClass);
}
if (sendNoSubscriberEvent && eventClass != NoSubscriberEvent.class &&
eventClass != SubscriberExceptionEvent.class) {
post(new NoSubscriberEvent(this, event));
}
}
}
private boolean postSingleEventForEventType(Object event, PostingThreadState postingState, Class<?> eventClass) {
CopyOnWriteArrayList<Subscription> subscriptions;
synchronized (this) {
// 从 map 中取出该类型的所以订阅者列表 subscriptions
subscriptions = subscriptionsByEventType.get(eventClass);
}
// 对这些订阅者逐个分发
if (subscriptions != null && !subscriptions.isEmpty()) {
for (Subscription subscription : subscriptions) {
postingState.event = event;
postingState.subscription = subscription;
boolean aborted = false;
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;
}
// 根据不同的 ThreadMode 进行分发
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 {
// 如果不是在主线程，则利用 Handler , mainThreadPoster 是一个 主线程的 Handler
mainThreadPoster.enqueue(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);
}
}根据不同的的 ThreadMode 进行不同的方法调用，这几种方法都比较简单，此处不表
invokeSubscriber(...) 方法使用了反射，最终调用订阅方法
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);
}
}
四、解除注册 unregister(...)
解除注册过程也比较简单，在 typesBySubcriber 和 subcriptionsByEventType 的 Map 中将相应的值移除即可
public synchronized void unregister(Object subscriber) {
List<Class<?>> subscribedTypes = typesBySubscriber.get(subscriber);
if (subscribedTypes != null) {
for (Class<?> eventType : subscribedTypes) {
unsubscribeByEventType(subscriber, eventType);
}
typesBySubscriber.remove(subscriber);
} else {
Log.w(TAG, "Subscriber to unregister was not registered before: " + subscriber.getClass());
}
} /** Only updates subscriptionsByEventType, not typesBySubscriber! Caller must update typesBySubscriber. */
private void unsubscribeByEventType(Object subscriber, Class<?> eventType) {
List<Subscription> subscriptions = subscriptionsByEventType.get(eventType);
if (subscriptions != null) {
int size = subscriptions.size();
for (int i = 0; i < size; i++) {
Subscription subscription = subscriptions.get(i);
if (subscription.subscriber == subscriber) {
subscription.active = false;
subscriptions.remove(i);
i--;
size--;
}
}
}
}
至此 EventBus 整个简要的分析过程结束了，相应了解更多的分析内容，可以参考下面的参考内容。
五、参考内容
eventbus3.0使用与源码分析
EventBus简介EventBusisapublish/subscribeeventbusoptimizedforAndroid.EventBus是一个基于发布/订阅模式的事件总线。其模型图如下从图可知，EventBus分为四个角色，消息发布者、事件总线、事件、消息订阅者。消息发布者把Event(消息)post(发送)到... 查看详情
eventbus3.0源码分析(代码片段)
...新到3.X版本，可见生命力极强呀。那么这篇博文就从EventBus3.0源码的角度分析一下其内部处理流程。使用流程： 注册：EventBus. 查看详情
eventbus3.0使用与源码分析(代码片段)
EventBus简介EventBusisapublish/subscribeeventbusoptimizedforAndroid.EventBus是一个基于发布/订阅模式的事件总线。其模型图如下从图可知，EventBus分为四个角色，消息发布者、事件总线、事件、消息订阅者。消息发布者把Event(消息)post(... 查看详情
eventbus3源码解析(代码片段)
提要：2月5号，greenrobot发布了EventBus3.0，3.0中引入了注解，我们可以通过@Subscribe注解，来标识一个事件处理方法。事件处理方法的命名更加灵活，且通过注解我们可以设定方法的执行优先级，执行线... 查看详情
eventbus3.0使用与源码分析(代码片段)
EventBus简介EventBusisapublish/subscribeeventbusoptimizedforAndroid.EventBus是一个基于发布/订阅模式的事件总线。其模型图如下从图可知，EventBus分为四个角色，消息发布者、事件总线、事件、消息订阅者。消息发布者把Event(消息)post(... 查看详情
eventbus3.0源码学习post
发送事件(post)当需要发送事件时，调用EventBus.getDefault().post(event)即可，EventBus会将事件发送给所有已经注册了监听该类事件的订阅者。post的实现如下：1publicvoidpost(Objectevent){2PostingThreadStatepostingState=currentPostingThreadState.get();3List&l 查看详情
eventbus3.0源码解析——06.总结
EventBus总结GitHub地址需要下载源码的，只需要将EventBus中的源码复制下来即可已将EventBus的整个源码解析过程上传了，点此下载大致流程懒加载的getDefault()，在注册的时候才初始化register(Objectsubscriber);//注册将当前class... 查看详情
eventbus3.0源码学习threadmode
线程模式POSTING：该模式不需要线程切换，为默认模式。在post线程直接调用事件订阅函数。MAIN：若post线程是主线程，则与POSTING模式一样；否则，由mainThreadPoster进行处理，从主线程调用事件订阅函数。BACKGROUND：若post线程不是主... 查看详情
eventbus3.0源码浅析与理解
1.简介EventBus是一个Android事件发布/订阅框架。传统的事件传递方式包括：Handler（消息处理机制，一般用于更新UI）、BroadCastReceiver（广播接收者）、Interface回调。EventBus优点：Activity、Fragment、Service与线... 查看详情
eventbus3.0源码解析
现在网上讲解EventBus的文章大多数都是针对2.x版本的，比较老旧，本篇文章希望可以给大家在新版本上面带来帮助。EventBus 是专门为Android设计的用于订阅，发布总线的库，用到这个库的app很多，因为它有很多的优点。比如：&... 查看详情
eventbus3.0源码解析——05.unregister注销(代码片段)
unregister（注销）unregister（Objectsubscriber）publicsynchronizedvoidunregister(Objectsubscriber)//获取当前Subscriber对象所缓存的所有eventType对象//这里的eventType代表Subscriber对象中所有标记了@Subscr 查看详情
eventbus3.0组件通信框架源码学习总结
一、初始化EventBus的初始化虽然用了单例模式，但是构造方法居然是public修饰符，可能是应对项目中的多线操作。//单例模式，针对并发情况进行了双层判断publicstaticEventBusgetDefault()if(defaultInstance==null)synchronized(Ev... 查看详情
eventbus3.0源码解析——03.register注册(代码片段)
register（注册）//注册事件接收EventBus.getDefault().register(this);//注册事件总线，在获取到eventbus单例后就可以注册了//注册方法中有两个至关重要的方法：//1.寻找到当前object对象中所有带@Subscribe注解标记的方法并... 查看详情
eventbus3.0组件通信框架源码学习总结
一、初始化EventBus的初始化虽然用了单例模式，但是构造方法居然是public修饰符，可能是应对项目中的多线操作。//单例模式，针对并发情况进行了双层判断publicstaticEventBusgetDefault()if(defaultInstance==null)synchronized(Ev... 查看详情
uboot源码简要分析
uboot源码简要分析 一、uboot源码整体框架源码解压以后，我们可以看到以下的文件和文件夹： cpu与处理器相关的文件。每个子目录中都包括cpu.c和interrupt.c、start.S、u-boot.lds。cpu.c：初始化CPU、设置指令Cache和数据Cache等inter... 查看详情
eventbus3.0源码浅析与理解
1.简介EventBus是一个Android事件发布/订阅框架。传统的事件传递方式包括：Handler（消息处理机制，一般用于更新UI）、BroadCastReceiver（广播接收者）、Interface回调。EventBus优点：Activity、Fragment、Service与线... 查看详情
elasticsearch之client源码简要分析
问题让我们带着问题去学习，效率会更高1 es集群只配置一个节点，client是否能够自动发现集群中的所有节点？是如何发现的？2 esclient如何做到负载均衡？3 一个esnode挂掉之后，esclient如何摘掉该节点？4 esclientnode... 查看详情
androiddebuggerd简要介绍和源码分析（转载）(代码片段)
...以android4.1为基础，分析debuggerd这个工具的使用方法和源码。1.Debuggerd简介debuggerd是一个daemon进程，在系统启动时随着init进程启动。主要负责将进程运行时的信息dump到文件或者控制台中。1.1debuggerd的运行原理创建一个名为... 查看详情