docs: public void init() {
          // Only do initialization if we're in INIT state coming into this method
          if (monitorState.compareAndSet(MonitorState.INIT.ordinal(), MonitorState.INITIALIZING.ordinal())) {
  
              if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                  Tr.debug(tc, "Monitor holder init, initializing");
              Object value;
              Collection<String> collection;
              Collection<File> baseline = new HashSet<File>();
              Map<UpdateMonitor, UpdateMonitor> oldMap = null;
  
              value = monitorRef.getProperty(FileMonitor.MONITOR_FILES);
              collection = Collections.emptyList(); // default will be empty list, use this to establish type for parse collection
              Object servicePid = monitorRef.getProperty(Constants.SERVICE_PID);
  
              boolean performBaseline = false;
              try {
                  scanLock.lock(); // Lock for updateMonitors modification
  
                  if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                      Tr.debug(tc, "Monitor holder init, scan lock obtained");
                  if (!updateMonitors.isEmpty()) {
                      oldMap = new HashMap<UpdateMonitor, UpdateMonitor>(updateMonitors);
                      updateMonitors.clear();
                  }
  
                  LinkedList<UpdateMonitor> newUpdateMonitors = new LinkedList<UpdateMonitor>();
  
                  // Create/Configure update monitors for files
                  collection = MetatypeUtils.parseStringCollection(servicePid, FileMonitor.MONITOR_FILES, value, collection);
                  for (String location : collection) {
                      try {
                          File file = new File(coreService.getLocationService().resolveString(location));
  
                          UpdateMonitor um = createUpdateMonitor(file, MonitorType.FILE, monitorFilter);
  
                          // Remove/preserve existing/matching monitors from the old map.
                          UpdateMonitor prevMonitor = oldMap == null ? null : oldMap.remove(um);
  
                          if (prevMonitor != null) {
                              // Preserve existing update monitors
                              updateMonitors.put(prevMonitor, prevMonitor);
                              if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                                  Tr.debug(tc, "Monitor holder init, updating existing u monitor " + um);
                              // need to destroy the um we just created because it is not going to be used
                              um.destroy();
                          } else {
                              newUpdateMonitors.add(um);
                              needsBaseline = true;
                              if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                                  Tr.debug(tc, "Monitor holder init, adding new u monitor " + um);
                          }
  
                      } catch (RuntimeException e) {
                          // FFDC generated for runtime exception
                          Tr.warning(tc, "createMonitorException", location, e.getLocalizedMessage());
                      }
                  }
  
                  // Create/Configure update monitors for directories
                  value = monitorRef.getProperty(FileMonitor.MONITOR_DIRECTORIES);
                  collection = Collections.emptyList(); // default will be empty list, use this to establish type for parse collection
                  collection = MetatypeUtils.parseStringCollection(servicePid, FileMonitor.MONITOR_DIRECTORIES, value, collection);
  
                  monitor = coreService.getReferencedMonitor(monitorRef);
                  if (monitor != null) {
  
                      if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                          Tr.debug(tc, "Monitor holder init, monitor not null");
                      for (String location : collection) {
                          try {
                              File file = new File(coreService.getLocationService().resolveString(location));
                              MonitorType type = null;
                              if (monitorRecurse) {
                                  if (monitorSelf) {
                                      type = MonitorType.DIRECTORY_RECURSE_SELF;
                                  } else {
                                      type = MonitorType.DIRECTORY_RECURSE;
                                  }
                              } else {
                                  if (monitorSelf) {
                                      type = MonitorType.DIRECTORY_SELF;
                                  } else {
                                      type = MonitorType.DIRECTORY;
                                  }
  
                              }
  
                              // NOTE: File caching is disabled. if/when we want it back, we can start
                              // checking against a minimum interval before setting the value.
                              UpdateMonitor um = createUpdateMonitor(file, type, monitorFilter);
  
                              // Remove/preserve existing/matching monitors from the old map.
                              UpdateMonitor prevMonitor = oldMap == null ? null : oldMap.remove(um);
  
                              if (prevMonitor != null) {
                                  if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                                      Tr.debug(tc, "Monitor holder init, found existing dir update monitor " + um);
  
                                  // Preserve existing update monitors
                                  updateMonitors.put(prevMonitor, prevMonitor);
                                  // need to destroy the um we just created because it is not going to be used
                                  um.destroy();
                              } else {
                                  if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                                      Tr.debug(tc, "Monitor holder init, adding new dir update monitor " + um);
                                  newUpdateMonitors.add(um);
                                  needsBaseline = true;
                              }
  
                          } catch (RuntimeException e) {
                              // FFDC generated for runtime exception
                              Tr.warning(tc, "createMonitorException", location, e.getLocalizedMessage());
                          }
                      }
  
                      if (needsBaseline || !!!oldMap.isEmpty()) {
                          // new properties or new/removed filesets -> new baseline
                          for (UpdateMonitor um : updateMonitors.keySet()) {
                              um.init(baseline);
                          }
                          for (UpdateMonitor um : newUpdateMonitors) {
                              um.init(baseline);
                              updateMonitors.put(um, um);
                          }
                          needsBaseline = true;
                      }
  
                      // Mark state as active, and schedule the task
                      monitorState.set(MonitorState.ACTIVE.ordinal());
                  }
                  performBaseline = needsBaseline;
                  needsBaseline = false;
              } finally {
                  scanLock.unlock();
                  if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                      Tr.debug(tc, "Monitor holder init, scan lock released");
              }
  
              if (monitor != null && FrameworkState.isValid()) {
                  // Notify (new) registered FileMonitor of the initial set of files that
                  // match their configuration. For "refreshes" the new resources will show
                  // up in the next scan (as add/remove/delete)
                  if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                      Tr.debug(tc, "Monitor holder init, calling initComplete");
                  if (performBaseline) {
                      if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                          Tr.debug(tc, "Baseline: " + baseline);
                      monitor.onBaseline(baseline);
                  }
  
                  start();
  
                  // destroy old monitors
                  if (oldMap != null && !oldMap.isEmpty()) {
                      for (UpdateMonitor um : oldMap.keySet()) {
                          if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                              Tr.debug(tc, "Monitor holder init, destroying old monitor " + um);
                          um.destroy();
                      }
                  }
              } else {
                  if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                      Tr.debug(tc, "Monitor holder init, monitor missing");
                  //monitor really shouldn't be null at this stage.. if it is then we need
                  //to shut up shop, as we cannot function.
                  monitorState.set(MonitorState.DESTROY.ordinal());
                  stop();
                  doDestroy();
              }
  
          }
      }