Problème avec java.util.logging et le fichier de verrouillage

Question

J'ai une application qui analyse un ensemble de fichiers. Et cette numérisation a lieu parallèlement. Je veux dire que si je télécharge 5 fichiers, cinq processus seront créés et commenceront à exécuter le travail parallèlement. Maintenant Pour consigner les exceptions pour les travaux en cours, il n'y a qu'un seul fichier journal. Le problème qui vient est, l'enregistreur crée un grand nombre de fichiers journaux comme -

mylogfile.log(actual log file) 

mylogfile.log.1 

mylogfile.log.2 

mylogfile.log.3 

mylogfile.log.4 

mylogfile.log.5 
... 

avec leurs fichiers de verrouillage respectifs. Voici l'extrait de code que j'ai utilisé:

public static Logger getLogger(final String className) { 
    final Logger logger = Logger.getLogger(className); 
    FileHandler fh; 
    try { 
     // This block configure the logger with handler and formatter 
     fh = new FileHandler("mylogfile.log", true); 
     logger.addHandler(fh); 
     logger.setLevel(Level.ALL); 
     logger.setUseParentHandlers(false); 
     fh.setFormatter(new SimpleFormatter()); 
    } catch (final SecurityException e) { 
     //   } 
    } catch (final IOException e) { 
     // 
    } 
    return logger; 
} 

Comment puis-je assurer que seul un fichier journal doit être utilisé pour écrire l'exception de tous les travaux en cours d'exécution .. ?? en parallèle

Merci,

Anish

Answer 1

Cela n'a pas grand-chose à voir avec des appels parallèles. Aussi bien d'un seul thread avec chaque appel à votre getLogger (même avec la même chaîne que l'argument) vous créez un nouveau FileHandler et l'ajoutez au logger existant. Peut-être que vous ne voulez pas faire tout le setup chaque fois que vous appelez votre getLogger- méthode.

//now we will create new Filehandler and set it to logger 
getLogger("identifier").log(Level.SEVERE, "Log to one file"); 
//now we have already one filehandler, but lets add one more 
getLogger("identifier").log(Level.SEVERE, "Log to two files"); 
//now we have already two filehandlers, but lets add one more 
getLogger("identifier").log(Level.SEVERE, "Log to three files");  

Configurer la connexion une fois et après que vous pouvez obtenir référence sur l'enregistreur via java.util.loggingLogger.getLogger. Overview from Sun donne plus d'idées sur la configuration de la journalisation via les fichiers de propriétés.

Answer 2

Vous pouvez utiliser une classe de localisation de singlton que vous pouvez récupérer l'enregistreur de, qui forcerait votre application à utiliser un enregistreur (ce qui signifie que vous aurez un fichier journal)

class LoggerLocator { 

    private static LoggerLocator locator = new LoggerLocator(); 
    private Logger logger; 

    /** 
    * 
    */ 
    private LoggerLocator() { 
     initLogger(); 
    } 

    /** 
    * @return 
    */ 
    public static LoggerLocator getLocator(){ 
     return locator; 
    } 

    /** 
    * @return 
    */ 
    public Logger getLogger() { 
     return logger; 
    } 

    /** 
    * 
    */ 
    private void initLogger() { 
     logger = Logger.getLogger("My General Logger"); 
     FileHandler fh; 
     try { 
      // This block configure the logger with handler and formatter 
      fh = new FileHandler("mylogfile.log", true); 
      logger.addHandler(fh); 
      logger.setLevel(Level.ALL); 
      logger.setUseParentHandlers(false); 
      fh.setFormatter(new SimpleFormatter()); 
     } catch (final SecurityException e) { 
      // } 
     } catch (final IOException e) { 
      // 
     } 
    } 
} 

Dans vos travaux vous obtiendra l'enregistreur par l'appel suivant:

Logger logger = LoggerLocator.getLocator().getLogger(); 

Answer 3

Je face au même problème et ce que je manque est une pratique de programmation standard que je fermer le gestionnaire de fichiers après avoir fini l'enregistrement. Vous pouvez donc créer plusieurs enregistreurs, mais assurez-vous de les fermer à la fin.

Après 2 lignes dans l'exemple ci-dessous:

• successLogFileHandler.close();
• failureLogFileHandler.close();

---

class LoggerExample { 
    private Logger loggerFailure; 
    private Logger loggerSuccess; 

    public void myLogger() { 
     // some code block 
     FileHandler successLogFileHandler = new FileHandler(successLogFile.getAbsolutePath()); 
     FileHandler failureLogFileHandler = new FileHandler(failureLogFile.getAbsolutePath()); 
     // Create loggers 
     loggerFailure = createLogger(STR_FAILURE_LOG_FILE, failureLogFileHandler, Level.INFO, customFormatter); 
     loggerSuccess = createLogger(STR_SUCCESS_LOG_FILE, successLogFileHandler, Level.INFO, customFormatter); 
     // Write messages into loggers 
     // and at the end close the file handlers 
     successLogFileHandler.close();  
     failureLogFileHandler.close(); 
    } 

    public static Logger createLogger(String strLoggerName, FileHandler handler, Level level, Formatter formatter) throws Exception 
    { 
     Logger logger = Logger.getLogger(strLoggerName); 
     logger.setLevel(level); 
     handler.setFormatter(formatter); 
     logger.addHandler(handler); 
     return logger; 
    } 
}