The listeners are called when the fireEvent method is invoked.
@param event The invalidation event to be fired.
167265
public void fireEvent(final InvalidationEvent event) {
        if (bUpdateInvalidationListener) {
            synchronized (hsInvalidationListeners) {
                if (invalidationListenerCount > 0) {
                    currentInvalidationListeners = new InvalidationListener[invalidationListenerCount];
                    hsInvalidationListeners.toArray(currentInvalidationListeners);
                } else {
                    currentInvalidationListeners = EMPTY_INV_LISTENERS;
                }
                bUpdateInvalidationListener = false;
            }
        }
        try {
        	event.m_cacheName = this.cacheNameNonPrefixed;
			for (int i = 0; i < currentInvalidationListeners.length; i++) {
				final InvalidationListener currentIL = currentInvalidationListeners[i];
				if (_async) {
					Scheduler.submit(new Runnable() {
						@Override
						public void run() {
							currentIL.fireEvent(event);
						}
					});
				} else {
					currentIL.fireEvent(event);
				}
			}
        }
        catch (Throwable t) {
        	com.ibm.ws.ffdc.FFDCFilter.processException(t, "com.ibm.ws.cache.DCEventSource.fireEvent", "85", this);
        	if (tc.isDebugEnabled()) {
        		Tr.debug(tc, "Exception thrown in fireEvent method of InvalidationListener\n" + t.toString());
        	}
        }
    }
458522
public void removeEventListener(EventListener listener)
    {
        if (listener instanceof HttpSessionAttributeListener)
            _sessionAttributeListeners.remove(listener);
        if (listener instanceof HttpSessionListener)
            _sessionListeners.remove(listener);
    }
394883
public void fire(TestCaseEvent event) {
        TestCaseResult testCase = testCaseStorage.get();
        event.process(testCase);

        notifier.fire(event);
    }
146455
protected synchronized void fireAttributeClearedEvent() {
		if (this.listenerList != null && isEventFirable()) {
			final AttributeChangeListener[] list = new AttributeChangeListener[this.listenerList.size()];
			this.listenerList.toArray(list);
			final AttributeChangeEvent event = new AttributeChangeEvent(
					this,
					Type.REMOVE_ALL,
					null,
					null,
					null,
					null);
			for (final AttributeChangeListener listener : list) {
				listener.onAttributeChangeEvent(event);
			}
		}
	}
279596
protected final void fireChildrenAdded(BeanContextMembershipEvent event)
	{
		Object listeners[];
		synchronized (bcmListeners)
		{
			listeners = bcmListeners.toArray();
		}
		for (int i = 0; i < listeners.length; i++)
		{
			BeanContextMembershipListener l = (BeanContextMembershipListener) listeners[i];
			l.childrenAdded(event);
		}
	}
1017260
@Override
    public <T> void fire(T event, NonManagedObserver<T> nonManagedObserver) {
        Validate.notNull(event, "Event must be specified");

        runtimeLogger.debug(event, true);
        // we start fresh pr new event
        handledThrowables.get().clear();

        List<ObserverMethod> observers = resolveObservers(event.getClass());
        List<ObserverMethod> interceptorObservers = resolveInterceptorObservers(event.getClass());

        ApplicationContext context = (ApplicationContext) getScopedContext(ApplicationScoped.class);
        // We need to know if we were to the one to Activate it to avoid:
        // * nested ApplicationContexts
        // * ending the scope to soon (to low in the stack)
        boolean activatedApplicationContext = false;
        try {
            if (!context.isActive()) {
                context.activate();
                activatedApplicationContext = true;
            }
            new EventContextImpl<T>(this, interceptorObservers, observers, nonManagedObserver, event,
                runtimeLogger).proceed();
        } catch (Exception e) {
            Throwable fireException = e;
            if (fireException instanceof InvocationException) {
                fireException = fireException.getCause();
            }
            if (handledThrowables.get().contains(fireException.getClass())) {
                UncheckedThrow.throwUnchecked(fireException);
            } else {
                fireException(fireException);
            }
        } finally {
            runtimeLogger.debug(event, false);
            if (activatedApplicationContext && context.isActive()) {
                context.deactivate();
            }
        }
    }
329020
public void dispatch(Event<?> event) {
		//eventManagement.dispatch(event);
		for (EventListener listener : KReflection.Holder.INSTANCE.listeners) {
			try {
				listener.handleEvent(event);
			} catch (Exception e) {
				// ignore
				// TODO add message kind
			}
		}
	}
3394
void firePropertyDataChanged(TreeDataEvent event) {
		if (this.nodeListeners != null) {
			for (final TreeNodeListener listener : this.nodeListeners) {
				if (listener != null) {
					listener.treeNodeDataChanged(event);
				}
			}
		}
		final N parent = getParentNode();
		if (parent != null) {
			parent.firePropertyDataChanged(event);
		}
	}
1347001
@Override
	public void fireEvent(String event) throws WidgetException {
		try {
			String javaScript = null;
			if (event.startsWith("mouse")) {
				javaScript = "if(document.createEvent){var evObj = document.createEvent('MouseEvents');evObj.initEvent('" + event
						+ "', true, false); arguments[0].dispatchEvent(evObj);} else if(document.createEventObject) { arguments[0].fireEvent('on" + event + "');}";
			} else {
				javaScript = "if(document.createEvent){var evObj = document.createEvent('HTMLEvents');evObj.initEvent('" + event
						+ "', true, false); arguments[0].dispatchEvent(evObj);} else if(document.createEventObject) { arguments[0].fireEvent('on" + event + "');}";
			}
			eval(javaScript);
		} catch (Exception e) {
			throw new WidgetException("Error while trying to fire event", getByLocator(), e);
		}
	}
364010
public void fire(TestSuiteEvent event) {
        TestSuiteResult testSuite = testSuiteStorage.get(event.getUid());
        event.process(testSuite);

        notifier.fire(event);
    }
1029427
public void fireEvent(final Event<?> event)
    {
        Scheduler.get().scheduleDeferred(new Scheduler.ScheduledCommand() {
            @Override
            public void execute() {
                bus.fireEventFromSource(event, dialog.getInterfaceModel().getId());
            }
        });

    }
275138
public void notifyListeners (DEvent event)
    {
        if (_listeners == null) {
            return;
        }

        for (int ii = 0, ll = _listeners.length; ii < ll; ii++) {
            Object listener = _listeners[ii];
            if (listener == null) {
                continue;
            }
            if (listener instanceof WeakReference<?>) {
                if ((listener = ((WeakReference<?>)listener).get()) == null) {
                    _listeners[ii] = null;
                    continue;
                }
            }

            try {
                // do any event specific notifications
                event.notifyListener(listener);

                // and notify them if they are listening for all events
                if (listener instanceof EventListener) {
                    ((EventListener)listener).eventReceived(event);
                }

            } catch (Exception e) {
                log.warning("Listener choked during notification", "list", listener,
                            "event", event, e);
            }
        }
    }
750080
public void eventReceived (DEvent event)
    {
        if (event instanceof InvocationResponseEvent) {
            InvocationResponseEvent ire = (InvocationResponseEvent)event;
            handleInvocationResponse(ire.getRequestId(), ire.getMethodId(), ire.getArgs());

        } else if (event instanceof InvocationNotificationEvent) {
            InvocationNotificationEvent ine = (InvocationNotificationEvent)event;
            handleInvocationNotification(ine.getReceiverId(), ine.getMethodId(), ine.getArgs());

        } else if (event instanceof MessageEvent) {
            MessageEvent mevt = (MessageEvent)event;
            if (mevt.getName().equals(ClientObject.CLOBJ_CHANGED)) {
                handleClientObjectChanged(((Integer)mevt.getArgs()[0]).intValue());
            }
        }
    }
573717
public void consumeEvents(Listener listener)
    {
        while (!isEmpty()) {
            Event event = remove();
            event.eventType.fireEvent(listener, event.eventParameters);
        }
    }
160362
public final void onRefreshEvent(RefreshEvent event) {
        Map<String, Object> changes = event.getSource();
        if (changes == RefreshEvent.ALL_KEYS) {
            disposeOfAllBeans();
            refreshAllConfigurationProperties();
        } else {
            disposeOfBeanSubset(changes.keySet());
            refreshSubsetOfConfigurationProperties(changes.keySet());
        }
    }
1317551
private void processEvent(EventModel<?> event) {
        if (!event.getSource().isCreatedFromInstance()) {
            error("event: " + event + "has invalid source");
            return;
        }
        debug("EventFired: " + event.toString() + " from " + event.getSource().getID());
        submit(() -> event.lifecycleCallback(EventLifeCycle.START));

        if (checkEventsControllers(event)) {
            submit(() -> event.lifecycleCallback(EventLifeCycle.APPROVED));
            submit(() -> event.lifecycleCallback(EventLifeCycle.RESOURCE));
            List<ResourceModel> resourceList = getMain().getResourceManager().generateResources(event);
            event.addResources(resourceList);
            submit(() -> event.lifecycleCallback(EventLifeCycle.LISTENERS));
            List<EventListenerModel> listenersTemp = event.getAllInformations().parallelStream()
                    .map(listeners::get)
                    .filter(Objects::nonNull)
                    .flatMap(Collection::stream)
                    .distinct()
                    .collect(Collectors.toList());

            List<CompletableFuture> futures = listenersTemp.stream()
                    .map(eventListener -> submit(() -> eventListener.eventFired(event)))
                    .collect(Collectors.toList());
            try {
                timeOut(futures, 1000);
            } catch (InterruptedException e) {
                error("interrupted", e);
            }
            submit(() -> event.lifecycleCallback(EventLifeCycle.OUTPUT));
            getMain().getOutputManager().passDataToOutputPlugins(event);
            submit(() -> event.lifecycleCallback(EventLifeCycle.ENDED));
            List<EventListenerModel> finishListenersTemp = event.getAllInformations().parallelStream()
                    .map(finishListeners::get)
                    .filter(Objects::nonNull)
                    .flatMap(Collection::stream)
                    .distinct()
                    .collect(Collectors.toList());

            futures = finishListenersTemp.stream()
                    .map(eventListener -> submit(() -> eventListener.eventFired(event)))
                    .collect(Collectors.toList());

            try {
                timeOut(futures, 1000);
            } catch (InterruptedException e) {
                error("interrupted", e);
            }
        } else {
            debug("canceling: " + event.toString() + " from " + event.getSource().getID());
            submit(() -> event.lifecycleCallback(EventLifeCycle.CANCELED));
        }
    }
992328
void firePropertyChildRemoved(TreeNodeRemovedEvent event) {
		if (this.nodeListeners != null) {
			for (final TreeNodeListener listener : this.nodeListeners) {
				if (listener != null) {
					listener.treeNodeChildRemoved(event);
				}
			}
		}
		final N parentNode = getParentNode();
		if (parentNode != null) {
			parentNode.firePropertyChildRemoved(event);
		}
	}