张荣旗
张荣旗

三方库-EventBus源码解析（二）

EventBus源码解析（二）

源码版本：

  • EventBus：3.3.1

导航：

  • 三方库-EventBus源码解析（一）
  • 三方库-EventBus源码解析（二）
  • 更多的文章看这里：主页

EventBus的post

EventBus --> post()

public void post(Object event) {
    // 1、获取当前线程的PostingThreadState，currentPostingThreadState是一个ThreadLocal对象，保证每个线程都有一个PostingThreadState对象，保证了线程安全。
    PostingThreadState postingState = currentPostingThreadState.get();
    // 2、获取当前线程的事件队列
    List eventQueue = postingState.eventQueue;
    // 3、将要发送的事件加入到当前线程的事件队列中
    eventQueue.add(event);

    // 4、判断是否正在发送事件，如果正在发送中，则不再执行里面的逻辑，因为事件已经添加到eventQueue中，它会继续走里面while循环的判断逻辑。
    if (!postingState.isPosting) {
        // 5、事件未被发送中，则初始化PostingThreadState，遍历事件队列发送。
        // 6、判断当前线程是否是主线程
        postingState.isMainThread = isMainThread();
        // 7、标记当前线程正在发送中
        postingState.isPosting = true;
        // 8、如果当前线程已经取消，则抛出异常。
        if (postingState.canceled) {
            throw new EventBusException("Internal error. Abort state was not reset");
        }
        try {eventQueue.remove(0)
            // 9、遍历事件队列，只要有事件，就一直发送。
            while (!eventQueue.isEmpty()) {
                // 10、发送事件，eventQueue.remove(0)说明post进来的事件，会依次发送。
                postSingleEvent(eventQueue.remove(0), postingState);
            }
        } finally {
            // 11、当前线程的所有事件完成，还原状态。
            postingState.isPosting = false;
            postingState.isMainThread = false;
        }
    }
}
 
 
post()方法，为事件的发送，兼容了多线程多发送多事件（多事件后面介绍）的情况。它使用ThreadLocal对象，保证每个线程都有一个PostingThreadState对象，保证了线程安全，它通过postingState.isMainThread记录了发送线程是否是主线程，然后它会依次进行发送。
 
 
 
  
说明：
 
  
     
   
  1.  postingState.isMainThread，记录了发送线程是否是主线程。
    2.  
   
  2. 步骤10，eventQueue.remove(0)，说明post()进来的事件，会依次发送。
    3.  
  
 
 
 
 
我们再来看一下currentPostingThreadState属性和PostingThreadState类。
 
 
private final ThreadLocal currentPostingThreadState = new ThreadLocal() {
    @Override
    protected PostingThreadState initialValue() {
        return new PostingThreadState();
    }
};

final static class PostingThreadState {
    final List eventQueue = new ArrayList<>(); // 发送线程的事件队列
    boolean isPosting; // 发送线程是否正在发送中
    boolean isMainThread; // 发送线程是否在主线程
    Subscription subscription; // 发送线程正在发布的Subscription
    Object event; // 发送线程正在发布的Event
    boolean canceled; // 发送线程是否已取消
}
 
 
PostingThreadState类为发送线程的状态类，状态信息看上面注释。currentPostingThreadState是一个ThreadLocal对象，保证每个线程都有一个PostingThreadState对象，保证了线程安全。
 
 
EventBus --> postSingleEvent
 
 
private void postSingleEvent(Object event, PostingThreadState postingState) throws Error {
    // 11、获取发送事件的Class
    Class eventClass = event.getClass();
    // 12、记录是否找到Subscription
    boolean subscriptionFound = false;
    if (eventInheritance) { // eventInheritance：事件是否有继承性，默认为true。
        // 13、事件有继承性，则发送[发送Event的所有父类以及所有父接口]的Event。
        // 14、获取到[发送Event的所有父类以及所有父接口]。
        List> eventTypes = lookupAllEventTypes(eventClass);
        // 15、遍历集合，发送单个事件。
        int countTypes = eventTypes.size();
        for (int h = 0; h < countTypes; h++) {
            Class clazz = eventTypes.get(h);
            // 16、发送单个事件，并判断是否找到Subscription（只要有一个有，就代表找到）。
            subscriptionFound |= postSingleEventForEventType(event, postingState, clazz);
        }
    } else {
        // 17、事件没有继承性，则发送[发送Event]的Event。
        subscriptionFound = postSingleEventForEventType(event, postingState, eventClass);
    }
    if (!subscriptionFound) {
        // 18、没有找到，判断是否打印Log，或者发送NoSubscriberEvent。
        if (logNoSubscriberMessages) {
            // 19、没有订阅者时，打印异常信息。
            logger.log(Level.FINE, "No subscribers registered for event " + eventClass);
        }
        if (sendNoSubscriberEvent && eventClass != NoSubscriberEvent.class &&
                eventClass != SubscriberExceptionEvent.class) {
            // 20、没有订阅者时，发送NoSubscriberEvent事件。
            post(new NoSubscriberEvent(this, event));
        }
    }
}

 
 
postSingleEvent()方法，为事件的发送，兼容了多线程单发送多事件的情况。如果事件有继承性，则发送[发送Event的所有父类以及所有父接口]的Event（此为多事件），否则则发送[发送Event]的Event，并判断没有找到，是否打印Log，或者发送NoSubscriberEvent。
 
 
我们再来看一下lookupAllEventTypes方法。
 EventBus --> lookupAllEventTypes
 
 
private static List> lookupAllEventTypes(Class eventClass) {
    // 使用了同步并且锁唯一，保证了线程有序执行。
    synchronized (eventTypesCache) {
        // 从缓存中获取当前Event的已维护的所有事件（父类、父接口）集合。
        List> eventTypes = eventTypesCache.get(eventClass);
        if (eventTypes == null) {
            // 集合为空，说明是第一次获取，则创建集合，并维护集合，并将其添加到缓存中。
            eventTypes = new ArrayList<>();
            // 当前clazz默认为eventClass
            Class clazz = eventClass;
            // 遍历当前clazz，只要不为空，就继续遍历。
            while (clazz != null) {
                // 添加当前clazz，第一次会把eventClass添加进去。
                eventTypes.add(clazz);
                // 添加当前clazz的所有接口class
                addInterfaces(eventTypes, clazz.getInterfaces());
                // 获取当前clazz的父类，以继续添加。
                clazz = clazz.getSuperclass();
            }
            // 将维护好的集合，添加到缓存。
            eventTypesCache.put(eventClass, eventTypes);
        }
        // 最后返回此维护好的所有事件（父类、父接口）集合。
        return eventTypes;
    }
}

// 循环递归添加当前类的所有的接口class到eventTypes。
// 举例：当前类，实现A、B两个接口，A实现C、D接口，B实现E接口，C、D、E未实现任何接口，最终会把A、B、C、D、E接口全部添加到eventTypes中。
static void addInterfaces(List> eventTypes, Class[] interfaces) {
    // 遍历所有接口
    for (Class interfaceClass : interfaces) {
        if (!eventTypes.contains(interfaceClass)) {
            // 此接口未被包含，则进行添加。
            eventTypes.add(interfaceClass);
            // 继续递归增加父接口的所有接口，使用递归以完成其所有父接口。
            addInterfaces(eventTypes, interfaceClass.getInterfaces());
        }
    }
}

 
 
lookupAllEventTypes()方法，为获取到[发送Event的所有父类以及所有父接口]。
 
 
EventBus --> postSingleEventForEventType
 
 
private boolean postSingleEventForEventType(Object event, PostingThreadState postingState, Class eventClass) {
    CopyOnWriteArrayList subscriptions;
    synchronized (this) {
        // 21、根据事件获取所有订阅它的订阅者，在同步方法内执行，保证了HashMap的get方法线程安全。
        subscriptions = subscriptionsByEventType.get(eventClass);
    }
    if (subscriptions != null && !subscriptions.isEmpty()) {
        // 22、有订阅者，遍历集合进行发送，返回true（代表已经找到）。
        // 23、遍历所有此类型的订阅者进行发送
        for (Subscription subscription : subscriptions) {
            // 24、记录发送线程正在发布的Event
            postingState.event = event;
            // 25、记录发送线程正在发布的Subscription
            postingState.subscription = subscription;
            // 26、是否是中断的
            boolean aborted;
            try {
                // 27、将事件发送给订阅者，postingState.isMainThread为post方法记录的。
                postToSubscription(subscription, event, postingState.isMainThread);
                // 28、事件是否被取消
                aborted = postingState.canceled;
            } finally {
                // 29、重置postingState
                postingState.event = null;
                postingState.subscription = null;
                postingState.canceled = false;
            }
            if (aborted) {
                // 30、事件被取消，则取消此类型的全部发布。
                break;
            }
        }
        return true;
    }
    // 31、无订阅者，不进行发送，返回false（代表没有找到）。
    return false;
}

 
 
postSingleEventForEventType()方法，为事件的发送，兼容了多线程单发送单事件的情况。根据事件获取所有订阅它的Subscription（持有订阅者对象、订阅方法对象），然后进行遍历依次发送。
 
 
EventBus --> postToSubscription
 
 
private void postToSubscription(Subscription subscription, Object event, boolean isMainThread) {
    // 32、根据订阅方法ThreadMode调用订阅方法
    switch (subscription.subscriberMethod.threadMode) {
        case POSTING:
            // 33、发布线程（默认）
            // 34、调用反射直接通知将事件
            invokeSubscriber(subscription, event);
            break;
        case MAIN:
            // 35、主线程
            if (isMainThread) {
                // 36、在Android上并且是主线程，或者不在Android上，调用反射直接通知。
                invokeSubscriber(subscription, event);
            } else {
                // 37、在Android上并且不是主线程，将事件添加到主线程队列中，在主线程调用。
                mainThreadPoster.enqueue(subscription, event);
            }
            break;
        case MAIN_ORDERED:
            // 38、主线程（有序）
            if (mainThreadPoster != null) {
                // 39、在Android上，始终将事件添加到主线程队列中，在主线程调用。
                mainThreadPoster.enqueue(subscription, event);
            } else {
                // 40、不在Android上，直接通过反射调用。
                invokeSubscriber(subscription, event);
            }
            break;
        case BACKGROUND:
            // 41、后台线程
            if (isMainThread) {
                // 42、在Android上并且是主线程，或者不在Android上，则将事件添加到后台线程队列中，在后台线程调用。
                backgroundPoster.enqueue(subscription, event);
            } else {
                // 43、在Android上并且不是主线程，直接通过反射调用。
                invokeSubscriber(subscription, event);
            }
            break;
        case ASYNC:
            // 44、异步线程
            // 45、将事件添加到异步线程队列中，在异步线程调用。
            asyncPoster.enqueue(subscription, event);
            break;
        default:
            throw new IllegalStateException("Unknown thread mode: " + subscription.subscriberMethod.threadMode);
    }
}

 
 
postToSubscription()方法，为事件的通知，兼容了多线程单发送单事件的情况。根据订阅方法的ThreadMode调用订阅方法，如果需要线程切换，则切换线程进行调用；否则，直接调用。
 
 
 
  
说明：
 
  
     
   
  1.  mainThreadPoster（即HandlerPoster）、backgroundPoster、asyncPoster这3个Poster，最终都会调用invokeSubscriber()方法进行通知，详细介绍看后面的-Poster。
    2.  
   
  2.  EventBus的注册，如果是粘性方法并且已经发送了此事件，也会调用postToSubscription()方法进行通知。
    3.  
  
 
 
 
 
EventBus --> invokeSubscriber
 
 
void invokeSubscriber(Subscription subscription, Object event) {
    try {
        // 46、反射调用订阅者对象的订阅方法，并传入event参数。
        subscription.subscriberMethod.method.invoke(subscription.subscriber, event);
    } catch (InvocationTargetException e) {
        // 47、处理调用订阅方法异常
        handleSubscriberException(subscription, event, e.getCause());
    } catch (IllegalAccessException e) {
        throw new IllegalStateException("Unexpected exception", e);
    }
}

private void handleSubscriberException(Subscription subscription, Object event, Throwable cause) {
    if (event instanceof SubscriberExceptionEvent) {
        // SubscriberExceptionEvent事件，判断调用订阅方法异常时是否打印Log（不发送事件防止递归）。
        if (logSubscriberExceptions) {
            // 调用订阅方法异常时，打印异常信息。
            // Don't send another SubscriberExceptionEvent to avoid infinite event recursion, just log
            logger.log(Level.SEVERE, "SubscriberExceptionEvent subscriber " + subscription.subscriber.getClass()
                    + " threw an exception", cause);
            SubscriberExceptionEvent exEvent = (SubscriberExceptionEvent) event;
            logger.log(Level.SEVERE, "Initial event " + exEvent.causingEvent + " caused exception in "
                    + exEvent.causingSubscriber, exEvent.throwable);
        }
    } else {
        // 普通事件，判断调用订阅方法异常时是否抛出异常、打印Log、发送SubscriberExceptionEvent。
        if (throwSubscriberException) {
            // 调用订阅方法异常时，抛出SubscriberException异常。
            throw new EventBusException("Invoking subscriber failed", cause);
        }
        if (logSubscriberExceptions) {
            // 调用订阅方法异常时，打印异常信息。
            logger.log(Level.SEVERE, "Could not dispatch event: " + event.getClass() + " to subscribing class "
                    + subscription.subscriber.getClass(), cause);
        }
        if (sendSubscriberExceptionEvent) {
            // 调用订阅方法异常时，发送SubscriberExceptionEvent事件。
            SubscriberExceptionEvent exEvent = new SubscriberExceptionEvent(this, cause, event,
                    subscription.subscriber);
            post(exEvent);
        }
    }
}

 
 
invokeSubscriber()方法，为反射调用订阅者对象的订阅方法，并传入event参数。handleSubscriberException()方法，为处理调用订阅方法异常，判断是否抛出异常、打印Log、发送SubscriberExceptionEvent。
 
 
线程模型
 
 
POSTING（发布线程）
 
 
事件的订阅和事件的发布处于同一线程（步骤34）。这是默认设置。事件传递意味着最少的开销，因为它完全避免了线程切换。因此，对于已知在非常短的时间内完成而不需要主线程的简单任务，这是推荐的模式。使用此模式的事件处理程序必须快速返回，以避免阻塞可能是主线程的发布线程。
 
 
 
  
说明：
 
  
     
   
  1. 事件的发布（可能会阻塞Android主线程）
    2.  
  
 
  
     
   
  • 事件的接收和发布在同一个线程，由于没有使用线程池，所以发布一定会阻塞线程。
    •  
  
 
  
     
   
  1. 事件的接收（可能会阻塞Android主线程）
    2.  
  
 
  
     
   
  • 事件的接收和发布在同一个线程，由于可能是主线程发送，所以接收可能会阻塞主线程，所以接收里不推荐执行耗时操作。
    •  
  
 
 
 
 
MAIN（主线程）
 
 
在Android上，订阅者将在Android的主线程（UI线程）中被调用。如果发布线程是主线程，则将直接调用订阅方法，从而阻塞发布线程（步骤36）。否则，事件将排队等待传递（非阻塞）（步骤37）。使用此模式的订阅者必须快速返回以避免阻塞主线程。如果不是在Android上，则行为与POSTING相同（步骤36）。
 
 
 
  
说明：
 
  
     
   
  1. 事件的发布（一定会阻塞Android主线程）
    2.  
  
 
  
     
   
  • 在Android上并且是主线程，或者不在Android上，则行为与POSTING相同（步骤36），所以发布一定会阻塞线程。
    •  
   
  • 在Android上并且不是主线程，将事件插入到主线程队列中（步骤37），由于使用了线程池，所以发布一定不会阻塞线程。
    •  
  
 
  
     
   
  1. 事件的接收（一定会阻塞Android主线程）
    2.  
  
 
  
     
   
  • 事件的接收在主线程，所以接收一定会阻塞主线程，所以接收里不能执行耗时操作。
    •  
  
 
  
     
   
  1. 事件的有序性（可能不是有序的）
    2.  
  
 
  
     
   
  • 在Android上，如果先非主线程发布（排队等待，可能会等待很长时间才会执行到自己），后主线程发布（直接调用），所以在Android上事件它可能是不是有序的。
    •  
   
  • 在非Android上，由于是直接调用，所以事件一定是有序的。
    •  
  
 
 
 
 
MAIN_ORDERED（主线程-有序）
 
 
在Android上，订阅者将在Android的主线程（UI线程）中被调用。与MAIN不同的是，事件总是排队等待传递（步骤39）。这确保了post调用是非阻塞的。
 
 
 
  
说明：
 
  
     
   
  1. 事件的发布（一定不会阻塞Android主线程）
    2.  
  
 
  
     
   
  • 在Android上，始终将事件添加到主线程队列中，在主线程调用，由于使用Handler发布，所以发布一定不会阻塞线程。
    •  
   
  • 不在Android上，则行为与POSTING相同，所以发布一定会阻塞线程。
    •  
  
 
  
     
   
  1. 事件的接收（一定会阻塞Android主线程）
    2.  
  
 
  
     
   
  • 事件的接收在主线程，所以接收一定会阻塞主线程，所以接收里不能执行耗时操作（同MAIN）。
    •  
  
 
  
     
   
  1. 事件的有序性（一定是有序的）
    2.  
  
 
  
     
   
  • 在Android上，始终添加到主线程队列，所以事件一定是有序的（步骤39）。
    •  
   
  • 在非Android上，由于是直接调用，所以事件一定是有序的（步骤40）。
    •  
  
 
 
 
 
BACKGROUND（后台）
 
 
在Android上，订阅者将在后台线程中被调用。如果发布线程不是主线程，则将在发布线程中直接调用订阅方法（步骤43）。如果发布线程是主线程，则EventBus使用一个单独的后台线程，它将按顺序传递其所有事件（步骤42）。使用此模式的订阅者应该尝试快速返回，以避免阻塞后台线程。如果不在Android上，则始终使用后台线程（步骤42）。
 
 
 
  
说明：
 
  
     
   
  1. 事件的发布（一定不会阻塞Android主线程）
    2.  
  
 
  
     
   
  • 在Android上并且是主线程，或者不在Android上，将事件插入到后台线程队列中（步骤42），由于使用了线程池，所以发布一定不会阻塞线程。
    •  
   
  • 在Android上并且不是主线程，则行为与POSTING相同（步骤43），所以发布一定会阻塞线程。
    •  
  
 
  
     
   
  1. 事件的接收（可能会阻塞线程池线程）
    2.  
  
 
  
     
   
  • 在Android上并且是主线程，使用backgroundPoster执行（步骤42），由于backgroundPoster里判断了如果正在执行中，则不再创建线程执行，而是用上次线程一块执行（详细看下面的-Poster-backgroundPoster），所以接收可能会阻塞后台线程，所以接收里不推荐执行耗时操作。
    •  
  
 
 
 
 
ASYNC（异步）
 
 
订阅者将在单独的线程中调用。这始终独立于发布线程和主线程。使用此模式发布事件从不等待订阅方法。如果订阅方法的执行可能需要一些时间（例如，用于网络访问），则应使用此模式。避免同时触发大量长时间运行的异步订阅方法以限制并发线程的数量。EventBus使用线程池高效地重用已完成异步订阅者通知中的线程。
 
 
 
  
说明：
 
  
     
   
  1. 事件的发布（一定不会阻塞Android主线程）
    2.  
  
 
  
     
   
  •  订阅者将在单独的线程中调用（步骤45），由于使用了线程池，所以发布一定不会阻塞线程。
    •  
  
 
  
     
   
  1. 事件的接收（不会阻塞线程池线程）
    2.  
  
 
  
     
   
  •  订阅者将在单独的线程中调用，使用asyncPoster执行（步骤45），由于asyncPoster里执行每次都在线程池里面使用新的线程执行（详细看下面的-Poster-asyncPoster），所以接收里能执行耗时操作。
    •  
  
 
 
 
 
小结
 
 
 
  
     
   
  1.  EventBus的post()，获取当前线程的事件队列，将要发送的事件加入到其中。
    2.  
   
  2.  遍历事件队列，只要有事件，就一直发送。
    3.  
   
  3. 判断事件是否有继承性，如果有则根据事件类型，找到当前Event的所有父类以及所有父接口的class集合，遍历这个集合，依次发送单个事件；否则，则只发送当前Event一个事件。
    4.  
   
  4. 根据事件获取所有订阅它的Subscription集合，遍历集合，将事件发送给订阅者的订阅方法。
    5.  
   
  5. 发送给订阅者时，根据订阅方法的线程模型调用订阅方法，如果需要线程切换，则切换线程进行调用；否则，直接调用。
    6.  
  
 
 
 
 
EventBus的postSticky
 
 
EventBus --> postSticky()
 
 
public void postSticky(Object event) {
    synchronized (stickyEvents) {
        // 1、将事件添加到粘性事件集合中
        stickyEvents.put(event.getClass(), event);
    }
    // 2、发送事件
    post(event);
}

 
 
 
  
说明：
 
  
     
   
  1.  EventBus的post()，只会发送给已经注册的订阅者。
    2.  
   
  2.  EventBus的postSticky()，会发送给已经注册的订阅者、之后要注册的订阅者的粘性订阅方法。
    3.  
  
 
 
 
 
小结
 
 
 
  
     
   
  1.  EventBus的postSticky()，将事件加入到stickyEvents集合中，当有新的订阅者注册后，如果该订阅者订阅了该事件的粘性订阅方法，则会发送给此方法。
    2.  
   
  2. 将事件发送给已经注册的订阅者。
    3.  
  
 
 
 
 
EventBus的注销
 
 
EventBus --> unregister()
 
 
public synchronized void unregister(Object subscriber) {
    // 1、获取订阅者订阅的所有事件
    List> subscribedTypes = typesBySubscriber.get(subscriber);
    if (subscribedTypes != null) {
        // 2、遍历此订阅者订阅的所有事件集合
        for (Class eventType : subscribedTypes) {
            // 3、通过eventType，将此事件的Subscription集合中含有该订阅者的Subscription，从集合中移除。
            unsubscribeByEventType(subscriber, eventType);
        }
        // 4、将此订阅者从typesBySubscriber中移除
        typesBySubscriber.remove(subscriber);
    } else {
        // 5、未注册，调用了注销，Log打印警告。
        logger.log(Level.WARNING, "Subscriber to unregister was not registered before: " + subscriber.getClass());
    }
}

 
 
unregister()方法，为注销订阅者。从typesBySubscriber中移除自己，从subscriptionsByEventType中移除subscriber内的多个事件类型。
 
 
EventBus --> unsubscribeByEventType()
 
 
private void unsubscribeByEventType(Object subscriber, Class eventType) {
    // 6、获取该事件的所有订阅者
    List subscriptions = subscriptionsByEventType.get(eventType);
    if (subscriptions != null) {
        int size = subscriptions.size();
        // 7、遍历上面的集合，找到此订阅者的Subscription，然后从此集合中移除。
        for (int i = 0; i < size; i++) {
            Subscription subscription = subscriptions.get(i);
            if (subscription.subscriber == subscriber) {
                // 8、找到，从此集合中移除。
                subscription.active = false;
                subscriptions.remove(i);
                i--;
                size--;
            }
        }
    }
}

 
 
unsubscribeByEventType()方法，为从subscriptionsByEventType中移除subscriber内的单个事件类型。
 
 
 
  
说明：
 
  
     
   
  1. 可以先遍历subscriptionsByEventType，然后再遍历subscriptionsByEventType的值，最后匹配subscriber，通过这种方式可以找到要移除的Subscription，但是这种实现要比上面实现效率低。
    2.  
  
 
 
 
 
小结
 
 
 
  
     
   
  1.  EventBus的注销，获取订阅者订阅的所有事件，遍历所有事件，通过事件从subscriptionsByEventType中，获取该事件的所有Subscription，遍历Subscription集合，找到此订阅者的Subscription，然后从此集合中移除。
    2.  
   
  2. 将此订阅者从typesBySubscriber中移除。
    3.  
  
 
 
 
 
Poster
 
 
Poster
 
 
public interface Poster {

    void enqueue(Subscription subscription, Object event);
}

 
 
Poster接口，它有一个enqueue方法，将subscription、event入队执行。它有3个实现类，为HandlerPoster、BackgroundPoster、AsyncPoster，我们来分别看一下。
 
 
mainThreadPoster
 
 
HandlerPoster
 
 
public class HandlerPoster extends Handler implements Poster {

    private final PendingPostQueue queue;
    private final int maxMillisInsideHandleMessage;
    private final EventBus eventBus;
    private boolean handlerActive;

    public HandlerPoster(EventBus eventBus, Looper looper, int maxMillisInsideHandleMessage) {
        // 这里传入的是主线程的Looper对象，所以这个Handler对象是主线程的Handler
        super(looper);
        this.eventBus = eventBus;
        this.maxMillisInsideHandleMessage = maxMillisInsideHandleMessage;
        // 创建一个事件队列
        queue = new PendingPostQueue();
    }

    public void enqueue(Subscription subscription, Object event) {
        // 根据传入的参数封装一个PendingPost对象
        PendingPost pendingPost = PendingPost.obtainPendingPost(subscription, event);
        synchronized (this) {
            // 将PendingPost加入到队列中
            // 发一个，执行一个，再发送，如果已经正在执行中，则不再立即执行，而是和上次一块执行
            queue.enqueue(pendingPost);
            if (!handlerActive) {
                handlerActive = true;
                // 调用Handler的sendMessage，发送事件回到主线程，最终会调用下面的handleMessage方法
                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();
            // 无限循环
            while (true) {
                PendingPost pendingPost = queue.poll(); // 获取并移除第一个
                // 进行两次检查，确保pendingPost不为null，如果为null直接跳出循环
                if (pendingPost == null) {
                    synchronized (this) {
                        // Check again, this time in synchronized
                        pendingPost = queue.poll();
                        if (pendingPost == null) {
                            // 一直循环到queue结束，才返回
                            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;
        }
    }
}

 
 
HandlerPoster类继承Handler，并实现Poster接口，enqueue方法将PendingPost加入到queue队列，然后发送空消息，最终走到handleMessage方法内，其内部判断，只要queue队列有数据就执行，最后使用反射调用订阅者的订阅方法。
 
 
backgroundPoster
 
 
BackgroundPoster
 
 
final class BackgroundPoster implements Runnable, Poster {

    private final PendingPostQueue queue;
    private final EventBus eventBus;

    private volatile boolean executorRunning;

    BackgroundPoster(EventBus eventBus) {
        this.eventBus = eventBus;
        // 初始化队列
        queue = new PendingPostQueue();
    }

    public void enqueue(Subscription subscription, Object event) {
        // 封装PendingPost对象
        PendingPost pendingPost = PendingPost.obtainPendingPost(subscription, event);
        synchronized (this) {
            // 将PendingPost对象加入到队列中
            // 发一个，执行一个，再发送，如果已经正在执行中，则不再立即执行，而是和上次一块执行
            queue.enqueue(pendingPost);
            if (!executorRunning) {
                executorRunning = true;
                // 这里使用到之前初始化的线程池
                eventBus.getExecutorService().execute(this);
            }
        }
    }

    // 线程池的执行回调
    @Override
    public void run() {
        // 实现同HandlerPoster
        try {
            try {
                // 无限循环
                while (true) {
                    //　获取队列中的PendingPost，进行双重检查，如果为null直接返回，结束循环
                    PendingPost pendingPost = queue.poll(1000);
                    if (pendingPost == null) {
                        synchronized (this) {
                            // Check again, this time in synchronized
                            pendingPost = queue.poll();
                            if (pendingPost == null) {
                                // 一直循环到queue结束，才返回
                                executorRunning = false;
                                return;
                            }
                        }
                    }
                    //使用反射的方式调用订阅者的订阅方法
                    eventBus.invokeSubscriber(pendingPost);
                }
            } catch (InterruptedException e) {
                eventBus.getLogger().log(Level.WARNING, Thread.currentThread().getName() + " was interruppted", e);
            }
        } finally {
            executorRunning = false;
        }
    }

}

 
 
BackgroundPoster类实现Runnable接口，并实现Poster接口，enqueue方法将PendingPost加入到queue队列，然后使用线程池执行此Runnable，最终走到run方法内，其内部判断，只要queue队列有数据就执行，最后使用反射调用订阅者的订阅方法。
 
 
asyncPoster
 
 
AsyncPoster
 
 
class AsyncPoster implements Runnable, Poster {

    private final PendingPostQueue queue;
    private final EventBus eventBus;

    AsyncPoster(EventBus eventBus) {
        this.eventBus = eventBus;
        queue = new PendingPostQueue();
    }

    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);
    }

}

 
 
AsyncPoster类实现Runnable接口，并实现Poster接口，enqueue方法将PendingPost加入到queue队列，然后使用线程池执行此Runnable，最终走到run方法内，其内部，获取queue队列最新数据然后执行，最后使用反射调用订阅者的订阅方法。
 
 
 
  
说明：
 
  
     
   
  1.  BackgroundPoster类和AsyncPoster类线程执行区别：BackgroundPoster类，如果正在执行中，则用上一次的线程执行，否则用新线程执行。AsyncPoster类，始终用新的线程执行。
    2.  
  
 
 
 
 
小结
 
 
 
  
     
   
  1.  Poster接口，它有3个实现类，为HandlerPoster、BackgroundPoster、AsyncPoster。
    2.  
   
  2. 这几个类，enqueue方法将PendingPost（持有subscription对象、event对象）加入到queue队列，然后切换到指定的线程执行，最后使用反射调用订阅者的订阅方法。
    3.  
  
 
 
 
 
SubscriberMethodFinder
 
 
SubscriberMethodFinder
 
 
class SubscriberMethodFinder {
    private static final int BRIDGE = 0x40;
    private static final int SYNTHETIC = 0x1000;

    private static final int MODIFIERS_IGNORE = Modifier.ABSTRACT | Modifier.STATIC | BRIDGE | SYNTHETIC;
    private static final Map, List> METHOD_CACHE = new ConcurrentHashMap<>();

    private List subscriberInfoIndexes;
    private final boolean strictMethodVerification;
    private final boolean ignoreGeneratedIndex;

    private static final int POOL_SIZE = 4;
    private static final FindState[] FIND_STATE_POOL = new FindState[POOL_SIZE];

    SubscriberMethodFinder(List subscriberInfoIndexes, boolean strictMethodVerification,
                           boolean ignoreGeneratedIndex) {
        this.subscriberInfoIndexes = subscriberInfoIndexes;
        this.strictMethodVerification = strictMethodVerification;
        this.ignoreGeneratedIndex = ignoreGeneratedIndex;
    }

    List findSubscriberMethods(Class subscriberClass) {
        // 1、先从之前缓存的集合中获取
        List subscriberMethods = METHOD_CACHE.get(subscriberClass);
        if (subscriberMethods != null) {
            // 2、如果之前缓存了，直接返回
            return subscriberMethods;
        }

        if (ignoreGeneratedIndex) {
            // 忽略注解处理器生成的索引，所以直接用反射获取，ignoreGeneratedIndex默认为false。
            subscriberMethods = findUsingReflection(subscriberClass);
        } else {
            // 3、获取所有订阅方法集合
            subscriberMethods = findUsingInfo(subscriberClass);
        }
        if (subscriberMethods.isEmpty()) {
            throw new EventBusException("Subscriber " + subscriberClass
                    + " and its super classes have no public methods with the @Subscribe annotation");
        } else {
            // 4、放入缓存集合中
            METHOD_CACHE.put(subscriberClass, subscriberMethods);
            return subscriberMethods;
        }
    }

    private List findUsingInfo(Class subscriberClass) {
        // 5、从数组中获取FindState对象，如果有直接返回，如果没有创建一个新的FindState对象。
        FindState findState = prepareFindState();
        // 6、根据事件订阅者初始化findState
        findState.initForSubscriber(subscriberClass);
        while (findState.clazz != null) {
            // 7、获取subscriberInfo，初始化为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增加订阅者方法
                        findState.subscriberMethods.add(subscriberMethod);
                    }
                }
            } else {
                // 8、通过反射的方式获取订阅者中的Method
                findUsingReflectionInSingleClass(findState);
            }
            // 移动到父类，以便后续操作。
            findState.moveToSuperclass();
        }
        // 释放
        return getMethodsAndRelease(findState);
    }

    // 从findState中获取订阅者所有方法并释放
    private List getMethodsAndRelease(FindState findState) {
        // 获取订阅者所有订阅方法集合
        List subscriberMethods = new ArrayList<>(findState.subscriberMethods);
        // findState进行回收
        findState.recycle();
        // 将回收后的findState，恢复到FIND_STATE_POOL中。
        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;
    }

    // 准备FindState对象，先从缓存中获取，如果有则获取并在缓存中移除；如果没有则进行创建并返回。
    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 SubscriberInfo getSubscriberInfo(FindState findState) {
        // 处理SubscriberInfoIndex添加手动创建的AbstractSubscriberInfo（一般不会手动创建）。
        // -findState.subscriberInfo != null：说明调用者调用findState.subscriberInfo = getSubscriberInfo(findState)的getSubscriberInfo(findState)返回的不为null，即subscriberInfoIndexes有值。
        // -findState.subscriberInfo.getSuperSubscriberInfo() != null：说明手动创建的AbstractSubscriberInfo，而不是注解处理器生成添加的SimpleSubscriberInfo。
        if (findState.subscriberInfo != null && findState.subscriberInfo.getSuperSubscriberInfo() != null) {
            SubscriberInfo superclassInfo = findState.subscriberInfo.getSuperSubscriberInfo();
            if (findState.clazz == superclassInfo.getSubscriberClass()) {
                // 要获取的Class等于父类的Class，则返回父类的Class。
                return superclassInfo;
            }
        }
        // 处理addIndex()添加的SubscriberInfoIndex。
        if (subscriberInfoIndexes != null) {
            for (SubscriberInfoIndex index : subscriberInfoIndexes) {
                SubscriberInfo info = index.getSubscriberInfo(findState.clazz);
                if (info != null) {
                    return info;
                }
            }
        }
        return null;
    }

    // 通过反射获取订阅者方法
    private List findUsingReflection(Class subscriberClass) {
        // 获取FindState，有复用。
        FindState findState = prepareFindState();
        // 初始化FindState，因为有复用，所以得初始化。
        findState.initForSubscriber(subscriberClass);
        while (findState.clazz != null) {
            // 反射获取，如果找到则存到findState.subscriberMethods里。
            findUsingReflectionInSingleClass(findState);
            // 移动到父类，会更改findState.clazz
            findState.moveToSuperclass();
        }
        return getMethodsAndRelease(findState);
    }

    private void findUsingReflectionInSingleClass(FindState findState) {
        Method[] methods;
        try {
            // 9、订阅者中所有声明的方法，放入数组中。
            // getDeclaredMethods，获取的是当前类的所有方法。
            // getMethods，获取的是当前类及其所有父类的所有公共方法。
            methods = findState.clazz.getDeclaredMethods();
            // 因为getDeclaredMethods，获取的是当前类的所有方法，所以findState.skipSuperClasses为false，为不跳过父类，即继续查找父类。
        } catch (Throwable th) {
            // Workaround for java.lang.NoClassDefFoundError, see https://github.com/greenrobot/EventBus/issues/149
            try {
                // 10、获取订阅者中声明的public方法，设置跳过父类
                // 因为getMethods，获取的是当前类及其所有父类的所有公共方法，所以findState.skipSuperClasses为true，为跳过父类，即不查找父类。
                methods = findState.clazz.getMethods();
            } catch (LinkageError error) { // super class of NoClassDefFoundError to be a bit more broad...
                String msg = "Could not inspect methods of " + findState.clazz.getName();
                if (ignoreGeneratedIndex) {
                    // 忽略注解生成器生成的索引，提示：请考虑使用EventBus注释处理器来避免反射。
                    msg += ". Please consider using EventBus annotation processor to avoid reflection.";
                } else {
                    // 忽略注解生成器生成的索引，提示：请使这个类对EventBus注释处理器可见，以避免反射。
                    msg += ". Please make this class visible to EventBus annotation processor to avoid reflection.";
                }
                throw new EventBusException(msg, error);
            }
            findState.skipSuperClasses = true;
        }
        // 遍历这些方法
        for (Method method : methods) {
            // 11、获取方法的修饰符:public、private等等
            int modifiers = method.getModifiers();
            // 12、订阅方法为public同时不是abstract、static、bridge、synthetic。
            if ((modifiers & Modifier.PUBLIC) != 0 && (modifiers & MODIFIERS_IGNORE) == 0) {
                // 13、方法参数类型数组
                Class[] parameterTypes = method.getParameterTypes();
                if (parameterTypes.length == 1) {
                    // 14、获取方法的注解
                    Subscribe subscribeAnnotation = method.getAnnotation(Subscribe.class);
                    // 15、如果有注解
                    if (subscribeAnnotation != null) {
                        Class eventType = parameterTypes[0];
                        // 16、将method和eventType放入到findState进行检查
                        if (findState.checkAdd(method, eventType)) {
                            // 17、获取注解中的threadMode对象
                            ThreadMode threadMode = subscribeAnnotation.threadMode();
                            // 18、新建一个SubscriberMethod对象，同时加入到findState中
                            findState.subscriberMethods.add(new SubscriberMethod(method, eventType, threadMode,
                                    subscribeAnnotation.priority(), subscribeAnnotation.sticky()));
                        }
                    }
                } else if (strictMethodVerification && method.isAnnotationPresent(Subscribe.class)) {
                    // 非1个参数，并且是严格模式，并且方法上有Subscribe注解，则抛异常警告。
                    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)) {
                // 方法的修饰符不符合，并且是严格模式，并且方法上有Subscribe注解，则抛异常警告。
                String methodName = method.getDeclaringClass().getName() + "." + method.getName();
                throw new EventBusException(methodName +
                        " is a illegal @Subscribe method: must be public, non-static, and non-abstract");
            }
        }
    }
}

 
 
SubscriberMethodFinder类findSubscriberMethods方法，找到此订阅者的所有订阅方法。它先从缓存中获取，如果缓存中有，直接返回；如果缓存中没有，通过反射或注解处理器的方式获取到此订阅者的所有订阅方法，并放入到集合中进行返回。
 
 
总结
 
 
以上就是全面的EventBus源码了！之后会出其它三方库源码系列，请及时关注。如果你有什么问题，大家评论区见！
 
 
最后推荐一下我的网站，开发者的技术博客: devbolg.cn ，目前包含android相关的技术，之后会面向全部开发者，欢迎大家来体验！
 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(三方库-EventBus源码解析（二）)

        

            

                
    
                    
  • 情绪觉察日记第37天
                        露露_e800

                        
    今天是家庭关系规划师的第二阶最后一天，慧萍老师帮我做了个案，帮我处理了埋在心底好多年的一份恐惧，并给了我深深的力量！这几天出来学习，爸妈过来婆家帮我带小孩，妈妈出于爱帮我收拾东西，并跟我先生和婆婆产生矛盾，妈妈觉得他们没有照顾好我…。今晚回家见到妈妈，我很欣赏她并赞扬她，妈妈说今晚要跟我睡我说好，当我们俩躺在床上准备睡觉的时候，我握着妈妈的手对她说:妈妈这几天辛苦你了，你看你多利害把我们的家收拾得
    
                    
    • 
                    
  • 一百九十四章. 自相矛盾
                        巨木擎天

                        
    唉！就这么一夜，林子感觉就像过了很多天似的，先是回了阳间家里，遇到了那么多不可思议的事情儿。特别是小伙伴们，第二次与自己见面时，僵硬的表情和恐怖的气氛，让自己如坐针毡，打从心眼里难受！还有东子，他现在还好吗？有没有被人欺负？护城河里的小鱼小虾们，还都在吗？水不会真的干枯了吧？那对相亲相爱漂亮的太平鸟儿，还好吧！春天了，到了做窝、下蛋、喂养小鸟宝宝的时候了，希望它们都能够平安啊！虽然没有看见家人，也
    
                    
    • 
                    
  • 10月|愿你的青春不负梦想-读书笔记-01
                        Tracy的小书斋

                        
    本书的作者是俞敏洪，大家都很熟悉他了吧。俞敏洪老师是我行业的领头羊吧，也是我事业上的偶像。本日摘录他书中第一章中的金句：『一个人如果什么目标都没有，就会浑浑噩噩，感觉生命中缺少能量。能给我们能量的，是对未来的期待。第一件事，我始终为了进步而努力。与其追寻全世界的骏马，不如种植丰美的草原，到时骏马自然会来。第二件事，我始终有阶段性的目标。什么东西能给我能量？答案是对未来的期待。』读到这里的时候，我便
    
                    
    • 
                    
  • C语言宏函数
                        南林yan
C语言c语言
                        
    一、什么是宏函数？通过宏定义的函数是宏函数。如下，编译器在预处理阶段会将Add(x,y)替换为((x)*(y))#defineAdd(x,y)((x)*(y))#defineAdd(x,y)((x)*(y))intmain(){inta=10;intb=20;intd=10;intc=Add(a+d,b)*2;cout<
                    
    • 
                    
  • 谢谢你们，爱你们！
                        鹿游儿

                        
    昨天家人去泡温泉，二个孩子也带着去，出发前一晚，匆匆下班，赶回家和孩子一起收拾。饭后，我拿出笔和本子（上次去澳门时做手帐的本子）写下了1\2\3\4\5\6\7\8\9,让后让小壹去思考，带什么出发去旅游呢？她在对应的数字旁边画上了，泳衣、泳圈、肖恩、内衣内裤、tapuy、拖鞋……画完后，就让她自己对着这个本子，将要带的，一一带上，没想到这次带的书还是这本《便便工厂》(晚上姑婆发照片过来，妹妹累得
    
                    
    • 
                    
  • 爬山后遗症
                        璃绛

                        
    爬山，攀登，一步一步走向制高点，是一种挑战。成功抵达是一种无法言语的快乐，在山顶吹吹风，看看风景，这是从未有过的体验。然而，爬山一时爽，下山腿打颤，颠簸的路，一路向下走，腿部力量不够，走起来抖到不行，停不下来了！第二天必定腿疼，浑身酸痛，坐立难安！
    
                    
    • 
                    
  • 《策划经理回忆录之二》
                        路基雅虎

                        
    话说三年变六年，飘了，飘了……眨眼，2013年5月，老吴回到了他的家乡——油城从新开启他的工作幻想症生涯。很庆幸，这是一家很有追求，同时敢于尝试的，且实力不容低调的新星房企——金源置业(前身泰源置业)更值得庆幸的是第一个盘就是油城十路的标杆之一:金源盛世。2013年5月，到2015年11月，两年的陪伴，迎来了一场大爆发。2000个筹，5万/筹，直接回笼1个亿！！！这……让我开始认真审视这座看似五线
    
                    
    • 
                    
  • 《大清方方案》| 第二话
                        谁佐清欢

                        
    和珅究竟说了些什么？竟能令堂堂九五之尊龙颜失色！此处暂且按下不表；单说这位乾隆皇帝，果真不愧是康熙从小带过的，一旦决定了要做的事，便杀伐决断毫不含糊。他当即亲自拟旨，着令和珅为钦差大臣，全权负责处理方方事件，并钦赐尚方宝剑，遇急则三品以下官员可先斩后奏。和珅身负皇上重托，岂敢有半点怠慢，当夜即率领相关人等，马不停蹄杀奔江汉。这一路上，和珅的几位幕僚一直在商讨方方事件的处置方案。有位年轻幕僚建议快刀
    
                    
    • 
                    
  • 【一起学Rust | 设计模式】习惯语法——使用借用类型作为参数、格式化拼接字符串、构造函数
                        广龙宇
一起学Rust#Rust设计模式rust设计模式开发语言
                        
    提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录前言一、使用借用类型作为参数二、格式化拼接字符串三、使用构造函数总结前言Rust不是传统的面向对象编程语言，它的所有特性，使其独一无二。因此，学习特定于Rust的设计模式是必要的。本系列文章为作者学习《Rust设计模式》的学习笔记以及自己的见解。因此，本系列文章的结构也与此书的结构相同（后续可能会调成结构），基本上分为三个部分
    
                    
    • 
                    
  • 本周第二次约练
                        2cfbdfe28a51

                        
    中原焦点团队中24初26刘霞2021.12.3约练161次，分享第368天当事人虽然是带着问题来的，但是咨询过程中发现，她是经过自己不断地调整和努力才走到现在的，看到当事人的不容易，找到例外，发现资源，力量感也就随之而来。增强画面感，或者说重温，会给当事人带来更深刻的感受。
    
                    
    • 
                    
  • 2022-07-08
                        保利学府里李楚怡1307022

                        
    ——保利碧桂园学府里——童梦奇趣【科学实验室】「7.9-7.10」✏玩出大智慧约99-144㎡二期全新升级力作
    
                    
    • 
                    
  • 直抒《紫罗兰永恒花园外传》
                        雷姆的黑色童话

                        
    没看过《紫罗兰永恒花园》的我莫名的看完了《紫罗兰永恒花园外传》，又莫名的被故事中的姐妹之情狠狠地感动了的一把。感动何在：困苦中相依为命的姐妹二人被迫分离，用一个人的自由换取另一个人的幸福。之后，虽相隔不知几许依旧心心念念彼此牵挂。这种深深的姐妹情谊就是令我为之动容的所在。贝拉和泰勒分别影片开始，海天之间一个孩童凭栏眺望，手中拿着折旧的信纸。镜头一转，挑灯伏案的薇尔莉特正在打字机前奋笔疾书。这些片段
    
                    
    • 
                    
  • 基于社交网络算法优化的二维最大熵图像分割
                        智能算法研学社（Jack旭）
智能优化算法应用图像分割算法php开发语言
                        
    智能优化算法应用：基于社交网络优化的二维最大熵图像阈值分割-附代码文章目录智能优化算法应用：基于社交网络优化的二维最大熵图像阈值分割-附代码1.前言2.二维最大熵阈值分割原理3.基于社交网络优化的多阈值分割4.算法结果：5.参考文献：6.Matlab代码摘要：本文介绍基于最大熵的图像分割，并且应用社交网络算法进行阈值寻优。1.前言阅读此文章前，请阅读《图像分割：直方图区域划分及信息统计介绍》htt
    
                    
    • 
                    
  • 如果做到轻松在股市赚钱？只要坚持这三个原则。
                        履霜之人

                        
    大A股里向来就有七亏二平一赚的说法，能赚钱的都是少数人。否则股市就成了慈善机构，人人都有钱赚，谁还要上班？所以说亏钱是正常的，或者说是应该的。那么那些赚钱的人又是如何做到的呢？普通人能不能找到捷径去分一杯羹呢？方法是有的，但要做到需要你有极高的自律。第一，控制仓位，散户最大的问题是追涨杀跌，只要涨起来，就把钱往股票上砸，然后被套，隔天跌的受不了，又一刀切，全部割肉。来来回回间，遍体鳞伤。所以散户首
    
                    
    • 
                    
  • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理
                        STU学生网页设计
网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
                        
    ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
    
                    
    • 
                    
  • 特殊的拜年
                        飘雪的天堂

                        
    文/雪儿大年初一，家家户户没有了轰响的鞭炮声，大街上没有了人流涌动的喧闹，几乎看不到人影，变得冷冷清清。天刚亮不大会儿，村里的大喇叭响了起来：由于当前正值疾病高发期，流感流行的高峰期。同时，新型冠状病毒感染的肺炎进入第二波流行的上升期。为了自己和他人的健康安全着想，请大家尽量不要串门拜年，不要在街里走动。可以通过手机微信，视频，电话，信息拜年……今年的春节真是特别。禁止燃放鞭炮，烟花爆竹，禁止出村
    
                    
    • 
                    
  • 398顺境，逆境
                        戴骁勇

                        
    2018.11.27周二雾霾最近儿子进入了一段顺境期，今天表现尤其不错。今天的数学测试成绩喜人，没有出现以往的计算错误，整个卷面书写工整，附加题也在规定时间内完成且做对。为迎接体育测试的锻炼有了质的飞跃。坐位体前屈成绩突飞猛进，估测成绩能达到12cm，这和上次测试的零分来比，简直是逆袭。儿子还在不断锻炼和提升，唯恐到时候掉链子。跑步姿势在我的调教下，逐渐正规起来，速度随之也有了提升。今晚测试的50
    
                    
    • 
                    
  • 想明白这个问题，你才能写下去
                        文自拾

                        
    春节放假的时候，又有一天梦见她，第二天她冒着漫天大雪，傻傻地跑来见我。她说，见见傻傻的我，天很冷，心很暖。她回去后，我写了一篇文章，题目叫——从此梦中只有你。我们没在一起的很长一段时间里，她都在我的心底，一次次出现在我的梦里。我对她说，在一起之前，是胆小且闷骚，在一起之后，我变得不要脸了。不要脸的——去爱你。那文章没写完，火车上，给她看了。我有点小失望，花了好几个小时写，她分分钟就看完，很希望她逐
    
                    
    • 
                    
  • 【JS】执行时长(100分) |思路参考+代码解析（C++）
                        l939035548
JS算法数据结构c++
                        
    题目为了充分发挥GPU算力，需要尽可能多的将任务交给GPU执行，现在有一个任务数组，数组元素表示在这1秒内新增的任务个数且每秒都有新增任务。假设GPU最多一次执行n个任务，一次执行耗时1秒，在保证GPU不空闲情况下，最少需要多长时间执行完成。题目输入第一个参数为GPU一次最多执行的任务个数，取值范围[1,10000]第二个参数为任务数组长度，取值范围[1,10000]第三个参数为任务数组，数字范围
    
                    
    • 
                    
  • 人工智能时代，程序员如何保持核心竞争力？
                        jmoych
人工智能
                        
    随着AIGC（如chatgpt、midjourney、claude等）大语言模型接二连三的涌现，AI辅助编程工具日益普及，程序员的工作方式正在发生深刻变革。有人担心AI可能取代部分编程工作，也有人认为AI是提高效率的得力助手。面对这一趋势,程序员应该如何应对?是专注于某个领域深耕细作，还是广泛学习以适应快速变化的技术环境?又或者，我们是否应该将重点转向AI无法轻易替代的软技能？让我们一起探讨程序员
    
                    
    • 
                    
  • 其二
                        十八尾喵

                        
    你知道吗？图片发自App我今天知道了你有喜欢的人，不是我。心空空的，整个人都不是我的了。可，怎么办？还是要好好的活着，毕竟你喜欢的人，我不能杀，可是我可以杀其他喜欢你的人呀！也罢，此生无缘，来世再见。鱼干
    
                    
    • 
                    
  • libyuv之linux编译
                        jaronho
Linuxlinux运维服务器
                        
    文章目录一、下载源码二、编译源码三、注意事项1、银河麒麟系统（aarch64）（1）解决armv8-a+dotprod+i8mm指令集支持问题（2）解决armv9-a+sve2指令集支持问题一、下载源码到GitHub网站下载https://github.com/lemenkov/libyuv源码，或者用直接用git克隆到本地，如：gitclonehttps://github.com/lemenko
    
                    
    • 
                    
  • webpack图片等资源的处理
                        dmengmeng

                        
    需要的loaderfile-loader（让我们可以引入这些资源文件）url-loader（其实是file-loader的二次封装）img-loader（处理图片所需要的）在没有使用任何处理图片的loader之前，比如说css中用到了背景图片，那么最后打包会报错的，因为他没办法处理图片。其实你只想能够使用图片的话。只加一个file-loader就可以，打开网页能准确看到图片。{test:/\.(p
    
                    
    • 
                    
  • ARM中断处理过程
                        落汤老狗
嵌入式linux
                        
    一、前言本文主要以ARM体系结构下的中断处理为例，讲述整个中断处理过程中的硬件行为和软件动作。具体整个处理过程分成三个步骤来描述：1、第二章描述了中断处理的准备过程2、第三章描述了当发生中的时候，ARM硬件的行为3、第四章描述了ARM的中断进入过程4、第五章描述了ARM的中断退出过程本文涉及的代码来自3.14内核。另外，本文注意描述ARM指令集的内容，有些sourcecode为了简短一些，删除了T
    
                    
    • 
                    
  • 如何成为段子手
                        欣雅阅读

                        
    我是一个尬聊大师，与朋友聊天经常把话题聊死，留我一个人在群里，望着自己打下的最后一句话无语凝噎。看到风趣幽默的朋友与人聊天，很是艳羡，觉得自己何时才能成为这样的段子手呢？一、段子是什么？“段子”一词在百度百科上的解释：本是相声中的一个艺术术语，指的是相声作品中一节或一段艺术内容。我的理解：段子就是一些搞笑的故事或者笑话。二、为什么要会说段子？不知道大家有没有这样的朋友，本来很无趣的聚会，只要有他参
    
                    
    • 
                    
  • Python爬虫解析工具之xpath使用详解
                        eqa11
python爬虫开发语言
                        
    文章目录Python爬虫解析工具之xpath使用详解一、引言二、环境准备1、插件安装2、依赖库安装三、xpath语法详解1、路径表达式2、通配符3、谓语4、常用函数四、xpath在Python代码中的使用1、文档树的创建2、使用xpath表达式3、获取元素内容和属性五、总结Python爬虫解析工具之xpath使用详解一、引言在Python爬虫开发中，数据提取是一个至关重要的环节。xpath作为一门
    
                    
    • 
                    
  • 主题升华随机抽总结
                        木棉咕噜

                        
    昨天晚上在火山灿教练那里抽了主题升华最后一关。一共抽了两个故事，现总结如下。第一个故事是《并不是你想象的那样》。主题一：有时候，面对别人一些貌似不合常情的行为，不要轻易的指责他，也许背后有我们所不知道的原因。在这一个主题里面，刚开始的时候，我没有加上貌似二字。所以就没有改动之后这么精准。主题二：有时候我们对他人善意的行为，可能会给我们带来一些意外的回报。主题三：面对同样一件事，因为不同的人看待问题
    
                    
    • 
                    
  • C++菜鸟教程 - 从入门到精通 第二节
                        DreamByte
c++
                        
    一.上节课的补充(数据类型)1.前言继上节课,我们主要讲解了输入,输出和运算符,我们现在来补充一下数据类型的知识上节课遗漏了这个知识点,非常的抱歉顺便说一下,博主要上高中了,更新会慢,2-4周更新一次对了,正好赶上中秋节,小编跟大家说一句:中秋节快乐!2.int类型上节课,我们其实只用了int类型int类型,是整数类型,它们存贮的是整数,不能存小数(浮点数)定义变量的方式很简单inta;//定义一
    
                    
    • 
                    
  • 这个世界为何对女性这么苛刻
                        遇见知见

                        
    图片发自App当今社会的女性，简直用金刚侠来形容都不为过。虽然早已过了男尊女卑的时代，但是这个世界并没有平等的对待女性。新时代的女性标准：上得了厅堂，下得了厨房，杀得了木马，翻得了围墙，开得起好车，买得起新房，斗得过二奶，打得过流氓，生得了孩子，养得了家庭。这个社会对女性有太多的不公平，既要求女性经济独立，又要求女性贤良淑德。所有的女性的在成长过程中没有任何一项是因为你是女性而给你开绿灯的。图片发
    
                    
    • 
                    
  • 日常演播练习0822
                        开阳春天

                        
    日常演播练习0822一、绕口令练习司小四和史小世，四月十四日十四时四十上集市，司小四买了四十四斤四两西红柿，史小世买了十四斤四两细蚕丝。司小四要拿四十四斤四两西红柿换史小世十四斤四两细蚕丝。史小世十四斤四两细蚕丝不换司小四四十四斤四两西红柿。司小四说我四十四斤四两西红柿可以增加营养防近视，史小世说我十四斤四两细蚕丝可以织绸织缎又抽丝。二、文本练习狗熊是动物街有名的美食家，它吃得多所以长得胖，它能吃
    
                    
    • 
                                
  • 安装数据库首次应用
                                    Array_06
javaoraclesql
                                    
    可是为什么再一次失败之后就变成直接跳过那个要求 
enter full pathname of java.exe的界面 
 
 
这个java.exe是你的Oracle 11g安装目录中例如：【F:\app\chen\product\11.2.0\dbhome_1\jdk\jre\bin】下的java.exe 。不是你的电脑安装的java jdk下的java.exe！ 
注意第一次，使用SQL D
    
                                
    • 
                                
  • Weblogic Server Console密码修改和遗忘解决方法
                                    bijian1013
Welogic
                                    
            在工作中一同事将Weblogic的console的密码忘记了，通过网上查询资料解决，实践整理了一下。 
一.修改Console密码 
        打开weblogic控制台，安全领域 --> myrealm -->&n
    
                                
    • 
                                
  • IllegalStateException: Cannot forward a response that is already committed
                                    Cwind
javaServlets
                                    
    对于初学者来说，一个常见的误解是：当调用 forward() 或者 sendRedirect() 时控制流将会自动跳出原函数。标题所示错误通常是基于此误解而引起的。   示例代码：   
protected void doPost() {
    if (someCondition) {
        sendRedirect();
    }
    forward(); // Thi
    
                                
    • 
                                
  • 基于流的装饰设计模式
                                    木zi_鸣
设计模式
                                    
    当想要对已有类的对象进行功能增强时，可以定义一个类，将已有对象传入，基于已有的功能，并提供加强功能。 
自定义的类成为装饰类 
 
模仿BufferedReader，对Reader进行包装，体现装饰设计模式 
 
装饰类通常会通过构造方法接受被装饰的对象，并基于被装饰的对象功能，提供更强的功能。 
装饰模式比继承灵活，避免继承臃肿，降低了类与类之间的关系 
 
装饰类因为增强已有对象，具备的功能该
    
                                
    • 
                                
  • Linux中的uniq命令
                                    被触发
linux
                                    
    Linux命令uniq的作用是过滤重复部分显示文件内容，这个命令读取输入文件，并比较相邻的行。在正常情 况下，第二个及以后更多个重复行将被删去，行比较是根据所用字符集的排序序列进行的。该命令加工后的结果写到输出文件中。输入文件和输出文件必须不同。如 果输入文件用“- ”表示，则从标准输入读取。 
AD： 
uniq [选项] 文件 
说明：这个命令读取输入文件，并比较相邻的行。在正常情况下，第二个
    
                                
    • 
                                
  • 正则表达式Pattern
                                    肆无忌惮_
Pattern
                                    
    正则表达式是符合一定规则的表达式，用来专门操作字符串，对字符创进行匹配，切割，替换，获取。 
  
例如，我们需要对QQ号码格式进行检验 
规则是长度6~12位  不能0开头  只能是数字，我们可以一位一位进行比较，利用parseLong进行判断，或者是用正则表达式来匹配[1-9][0-9]{4,14} 或者 [1-9]\d{4,14} 
&nbs
    
                                
    • 
                                
  • Oracle高级查询之OVER (PARTITION BY ..)
                                    知了ing
oraclesql
                                    
    一、rank()/dense_rank() over(partition by ...order by ...) 
 
现在客户有这样一个需求，查询每个部门工资最高的雇员的信息，相信有一定oracle应用知识的同学都能写出下面的SQL语句： 
 
 select e.ename, e.job, e.sal, e.deptno  
  from scott.emp e,  
       (se
    
                                
    • 
                                
  • Python调试
                                    矮蛋蛋
pythonpdb
                                    
    原文地址： 
http://blog.csdn.net/xuyuefei1988/article/details/19399137 
1、下面网上收罗的资料初学者应该够用了，但对比IBM的Python 代码调试技巧： 
 
IBM：包括 pdb 模块、利用 PyDev 和 Eclipse 集成进行调试、PyCharm 以及 Debug 日志进行调试： 
 
http://www.ibm.com/d
    
                                
    • 
                                
  • webservice传递自定义对象时函数为空，以及boolean不对应的问题
                                    alleni123
webservice
                                    
    今天在客户端调用方法 
NodeStatus status=iservice.getNodeStatus(). 
 
结果NodeStatus的属性都是null。 
 
进行debug之后，发现服务器端返回的确实是有值的对象。 
 
后来发现原来是因为在客户端，NodeStatus的setter全部被我删除了。 
本来是因为逻辑上不需要在客户端使用setter， 结果改了之后竟然不能获取带属性值的
    
                                
    • 
                                
  • java如何干掉指针，又如何巧妙的通过引用来操作指针————>说的就是java指针
                                    百合不是茶

                                    
    C语言的强大在于可以直接操作指针的地址，通过改变指针的地址指向来达到更改地址的目的,又是由于c语言的指针过于强大，初学者很难掌握， java的出现解决了c，c++中指针的问题 java将指针封装在底层，开发人员是不能够去操作指针的地址，但是可以通过引用来间接的操作： 
  
定义一个指针p来指向a的地址（&是地址符号）： 
        
    
                                
    • 
                                
  • Eclipse打不开，提示“An error has occurred.See the log file ***/.log”
                                    bijian1013
eclipse
                                    
    打开eclipse工作目录的\.metadata\.log文件，发现如下错误： 
 
!ENTRY org.eclipse.osgi 4 0 2012-09-10 09:28:57.139 
!MESSAGE Application error 
!STACK 1 
java.lang.NoClassDefFoundError: org/eclipse/core/resources/IContai
    
                                
    • 
                                
  • spring aop实例annotation方法实现
                                    bijian1013
javaspringAOPannotation
                                    
            在spring aop实例中我们通过配置xml文件来实现AOP，这里学习使用annotation来实现，使用annotation其实就是指明具体的aspect,pointcut和advice。1.申明一个切面(用一个类来实现)在这个切面里,包括了advice和pointcut 
AdviceMethods.jav
    
                                
    • 
                                
  • [Velocity一]Velocity语法基础入门
                                    bit1129
velocity
                                    
    用户和开发人员参考文档 
http://velocity.apache.org/engine/releases/velocity-1.7/developer-guide.html 
  注释 
1.行级注释## 
2.多行注释#*  *# 
  变量定义 
使用$开头的字符串是变量定义，例如$var1, $var2, 
  赋值 
使用#set为变量赋值，例
    
                                
    • 
                                
  • 【Kafka十一】关于Kafka的副本管理
                                    bit1129
kafka
                                    
    1. 关于request.required.acks 
  
request.required.acks控制者Producer写请求的什么时候可以确认写成功，默认是0， 
0表示即不进行确认即返回。 
1表示Leader写成功即返回，此时还没有进行写数据同步到其它Follower Partition中 
-1表示根据指定的最少Partition确认后才返回，这个在 
  
Th
    
                                
    • 
                                
  • lua统计nginx内部变量数据
                                    ronin47
lua nginx　 统计
                                    
    server {
    listen 80;
    server_name photo.domain.com;
    location /{set $str $uri;
        content_by_lua '
            local url = ngx.var.uri
            local res = ngx.location.capture(
    
                                
    • 
                                
  • java-11.二叉树中节点的最大距离
                                    bylijinnan
java
                                    
    
import java.util.ArrayList;
import java.util.List;


public class MaxLenInBinTree {

	/*
	 a.			1
	 		   /  \
	 		  2    3
	 		 / \  / \
	 		4   5 6  7
	 	max=4	pass "root"
	 
    
                                
    • 
                                
  • Netty源码学习-ReadTimeoutHandler
                                    bylijinnan
javanetty
                                    
     
ReadTimeoutHandler的实现思路： 
开启一个定时任务，如果在指定时间内没有接收到消息，则抛出ReadTimeoutException 
这个异常的捕获，在开发中，交给跟在ReadTimeoutHandler后面的ChannelHandler，例如 
 
 

private final ChannelHandler timeoutHandler =
	new ReadTim
    
                                
    • 
                                
  • jquery验证上传文件样式及大小(好用)
                                    cngolon
文件上传jquery验证
                                    
    <!DOCTYPE html>
<html>
<head>
    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
    <script src="jquery1.8/jquery-1.8.0.
    
                                
    • 
                                
  • 浏览器兼容【转】
                                    cuishikuan
css浏览器IE
                                    
    浏览器兼容问题一：不同浏览器的标签默认的外补丁和内补丁不同 
 
问题症状：随便写几个标签，不加样式控制的情况下，各自的margin 和padding差异较大。 
 
碰到频率:100% 
 
解决方案：CSS里    *{margin:0;padding:0;} 
 
备注：这个是最常见的也是最易解决的一个浏览器兼容性问题，几乎所有的CSS文件开头都会用通配符*来设
    
                                
    • 
                                
  • Shell特殊变量：Shell $0, $#, $*, $@, $?, $$和命令行参数
                                    daizj
shell$#$?特殊变量
                                    
    前面已经讲到，变量名只能包含数字、字母和下划线，因为某些包含其他字符的变量有特殊含义，这样的变量被称为特殊变量。例如，$ 表示当前Shell进程的ID，即pid，看下面的代码：   
 
  $echo $$  
   
运行结果 
29949 
   特殊变量列表   变量 含义   $0 当前脚本的文件名   $n 传递给脚本或函数的参数。n 是一个数字，表示第几个参数。例如，第一个
    
                                
    • 
                                
  • 程序设计KISS 原则-------KEEP IT SIMPLE, STUPID!
                                    dcj3sjt126com
unix
                                    
    翻到一本书，讲到编程一般原则是kiss：Keep It Simple, Stupid.对这个原则深有体会，其实不仅编程如此，而且系统架构也是如此。 
 KEEP IT SIMPLE, STUPID! 编写只做一件事情，并且要做好的程序；编写可以在一起工作的程序，编写处理文本流的程序，因为这是通用的接口。这就是UNIX哲学.所有的哲学真 正的浓缩为一个铁一样的定律，高明的工程师的神圣的“KISS 原
    
                                
    • 
                                
  • android Activity间List传值
                                    dcj3sjt126com
Activity
                                    
    第一个Activity： 
import java.util.ArrayList;import java.util.HashMap;import java.util.List;import java.util.Map;import android.app.Activity;import android.content.Intent;import android.os.Bundle;import a
    
                                
    • 
                                
  • tomcat 设置java虚拟机内存
                                    eksliang
tomcat 内存设置
                                    
    转载请出自出处：http://eksliang.iteye.com/blog/2117772 
http://eksliang.iteye.com/ 
常见的内存溢出有以下两种: 
java.lang.OutOfMemoryError: PermGen space  
java.lang.OutOfMemoryError: Java heap space 
  
------------
    
                                
    • 
                                
  • Android 数据库事务处理
                                    gqdy365
android
                                    
    使用SQLiteDatabase的beginTransaction()方法可以开启一个事务，程序执行到endTransaction() 方法时会检查事务的标志是否为成功，如果程序执行到endTransaction()之前调用了setTransactionSuccessful() 方法设置事务的标志为成功则提交事务，如果没有调用setTransactionSuccessful() 方法则回滚事务。事
    
                                
    • 
                                
  • Java 打开浏览器
                                    hw1287789687
打开网址open浏览器open browser打开url打开浏览器
                                    
    使用java 语言如何打开浏览器呢? 
我们先研究下在cmd窗口中,如何打开网址 
使用IE 打开 
D:\software\bin>cmd /c start iexplore http://hw1287789687.iteye.com/blog/2153709 
使用火狐打开 
D:\software\bin>cmd /c start firefox http://hw1287789
    
                                
    • 
                                
  • ReplaceGoogleCDN：将 Google CDN 替换为国内的 Chrome 插件
                                    justjavac
chromeGooglegoogle apichrome插件
                                    
    Chrome Web Store 安装地址： https://chrome.google.com/webstore/detail/replace-google-cdn/kpampjmfiopfpkkepbllemkibefkiice 
 
 由于众所周知的原因，只需替换一个域名就可以继续使用Google提供的前端公共库了。 同样，通过script标记引用这些资源，让网站访问速度瞬间提速吧
    
                                
    • 
                                
  • 进程VS.线程
                                    m635674608
线程
                                    
    资料来源： 
http://www.liaoxuefeng.com/wiki/001374738125095c955c1e6d8bb493182103fac9270762a000/001397567993007df355a3394da48f0bf14960f0c78753f000 1、Apache最早就是采用多进程模式 2、IIS服务器默认采用多线程模式 3、多进程优缺点 优点： 
多进程模式最大
    
                                
    • 
                                
  • Linux下安装MemCached
                                    字符串
memcached
                                    
    前提准备：1. MemCached目前最新版本为：1.4.22，可以从官网下载到。2. MemCached依赖libevent，因此在安装MemCached之前需要先安装libevent。2.1 运行下面命令，查看系统是否已安装libevent。[root@SecurityCheck ~]# rpm -qa|grep libevent libevent-headers-1.4.13-4.el6.n
    
                                
    • 
                                
  • java设计模式之--jdk动态代理（实现aop编程）
                                    Supanccy2013
javaDAO设计模式AOP
                                    
        与静态代理类对照的是动态代理类，动态代理类的字节码在程序运行时由Java反射机制动态生成，无需程序员手工编写它的源代码。动态代理类不仅简化了编程工作，而且提高了软件系统的可扩展性，因为Java 反射机制可以生成任意类型的动态代理类。java.lang.reflect 包中的Proxy类和InvocationHandler 接口提供了生成动态代理类的能力。 
&
    
                                
    • 
                                
  • Spring 4.2新特性-对java8默认方法(default method)定义Bean的支持
                                    wiselyman
spring 4
                                    
    2.1 默认方法(default method) 
 
 java8引入了一个default medthod; 
 用来扩展已有的接口,在对已有接口的使用不产生任何影响的情况下,添加扩展 
 使用default关键字 
 Spring 4.2支持加载在默认方法里声明的bean 
  
2.2 
 
 将要被声明成bean的类 
  
public class DemoService {
    
    
                                
    •