Come gestisco correttamente il tipo di overflow pollEvents() in un servizio di vigilanza?

Question

Sto utilizzando un servizio di controllo per monitorare una directory e attivare la logica sui file appena creati. Una delle sfide che ho sperimentato di recente è che un overflow viene attivato quando è necessario elaborare un volume elevato di file e viene copiato nella directory di controllo troppo veloce da gestire.

Il API dice questo di overflow:

I file system possono segnalare gli eventi più velocemente di quanto possano essere recuperati o trattati e un'implementazione possono imporre un limite specificato il numero di eventi che si può accumulare. Quando un'implementazione scarta consapevolmente gli eventi, ordina il metodo pollEvents della chiave per restituire un elemento con un tipo di evento OVERFLOW.

La mia domanda è, come posso gestire correttamente l'overflow, senza perdere nessuno degli eventi che devono essere elaborati?

Il mio codice watchservice assomiglia:

  Path myDir = Paths.get(srcDir); 
      try(WatchService watcher = myDir.getFileSystem().newWatchService()){ 
       myDir.register(watcher, ENTRY_CREATE,ENTRY_MODIFY); 
       int x = 0; 
       for(;;){ 
        x++; 
        WatchKey watchKey = watcher.take(); 
        LOGGER.debug("Event # {}",x); 
        List<WatchEvent<?>> events = watchKey.pollEvents(); 
        LOGGER.info("Events Size {}",events.size()); 
        for (WatchEvent event : events) { 
         if(event.kind() == OVERFLOW){ 
          LOGGER.error("The Maximum watchService events has been reached!"); 
          System.exit(1); //I exit so I know there is a problem - but how should I handle this? 
         } 
         if (event.kind() == ENTRY_CREATE) { 
          LOGGER.info("File created: " + event.context().toString()); 
          LOGGER.info("Beginning Processing:" +event.context().toString()); 
          ...business logic here... 
         } 
        } 
        watchKey.reset(); 
       } 
      ... 

Answer 1

Non ho mai visto la manifestazione di overflow nella pratica. Ha lo scopo di informarti che dovrai rielaborare qualunque directory tu stia guardando. Non è necessario uscire dal programma, è sufficiente eseguire la ricerca per indicizzazione della directory utilizzando una chiamata File.list() a thread singolo. Ho tagliato e incollato come lo gestisco qui sotto. Questo codice ...

1) registra un problema

2) imposta un flag per innescare una reprocess directory che striscia tutti i file in una directory

3) salta il resto della lavorazione di questo WatchEvent

// log overflow events and trigger reprocess later. 
if (kind == OVERFLOW) 
{ 
    logger.warn("File listener recieved an overflow event. You should probably check into this"); 
    overflowTriggeredFlag = true; 
    continue; 
}