Index: log4j-over-slf4j/src/main/java/org/apache/log4j/Log4jLoggerFactory.java IDEA additional info: Subsystem: com.intellij.openapi.diff.impl.patch.CharsetEP <+>windows-1252 =================================================================== --- log4j-over-slf4j/src/main/java/org/apache/log4j/Log4jLoggerFactory.java (revision 730ca751a9e7e30f0dc8025ebb57f15507ff0d4e) +++ log4j-over-slf4j/src/main/java/org/apache/log4j/Log4jLoggerFactory.java (revision ) @@ -16,7 +16,8 @@ package org.apache.log4j; -import java.util.Hashtable; +import java.util.concurrent.ConcurrentHashMap; +import java.util.concurrent.ConcurrentMap; import org.apache.log4j.spi.LoggerFactory; import org.slf4j.helpers.Util; @@ -33,7 +34,7 @@ class Log4jLoggerFactory { // String, Logger - private static Hashtable log4jLoggers = new Hashtable(); + private static ConcurrentMap log4jLoggers = new ConcurrentHashMap(); private static final String LOG4J_DELEGATION_LOOP_URL = "http://www.slf4j.org/codes.html#log4jDelegationLoop"; @@ -53,26 +54,26 @@ } } - public static synchronized Logger getLogger(String name) { - if (log4jLoggers.containsKey(name)) { - return (org.apache.log4j.Logger) log4jLoggers.get(name); + public static Logger getLogger(String name) { + org.apache.log4j.Logger instance = (Logger) log4jLoggers.get(name); + if (instance != null) { + return instance; } else { - Logger log4jLogger = new Logger(name); - - log4jLoggers.put(name, log4jLogger); - return log4jLogger; + Logger newInstance = new Logger(name); + instance = (Logger) log4jLoggers.putIfAbsent(name, newInstance); + return instance != null ? instance : newInstance; } } - + - public static synchronized Logger getLogger(String name, LoggerFactory loggerFactory) { - if (log4jLoggers.containsKey(name)) { - return (org.apache.log4j.Logger) log4jLoggers.get(name); + public static Logger getLogger(String name, LoggerFactory loggerFactory) { + org.apache.log4j.Logger instance = (Logger) log4jLoggers.get(name); + if (instance != null) { + return instance; - } else { + } else { - Logger log4jLogger = loggerFactory.makeNewLoggerInstance(name); - - log4jLoggers.put(name, log4jLogger); - return log4jLogger; + Logger newInstance = loggerFactory.makeNewLoggerInstance(name); + instance = (Logger) log4jLoggers.putIfAbsent(name, newInstance); + return instance != null ? instance : newInstance; - } + } } } Index: jcl-over-slf4j/src/main/java/org/apache/commons/logging/impl/SLF4JLogFactory.java IDEA additional info: Subsystem: com.intellij.openapi.diff.impl.patch.CharsetEP <+>windows-1252 =================================================================== --- jcl-over-slf4j/src/main/java/org/apache/commons/logging/impl/SLF4JLogFactory.java (revision 730ca751a9e7e30f0dc8025ebb57f15507ff0d4e) +++ jcl-over-slf4j/src/main/java/org/apache/commons/logging/impl/SLF4JLogFactory.java (revision ) @@ -18,10 +18,10 @@ import java.util.ArrayList; import java.util.Enumeration; -import java.util.HashMap; import java.util.Hashtable; import java.util.List; -import java.util.Map; +import java.util.concurrent.ConcurrentHashMap; +import java.util.concurrent.ConcurrentMap; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogConfigurationException; @@ -58,13 +58,13 @@ * The {@link org.apache.commons.logging.Log}instances that have already been * created, keyed by logger name. */ - Map loggerMap; + ConcurrentMap loggerMap; /** * Public no-arguments constructor required by the lookup mechanism. */ public SLF4JLogFactory() { - loggerMap = new HashMap(); + loggerMap = new ConcurrentHashMap(); } // ----------------------------------------------------- Manifest Constants @@ -148,22 +148,20 @@ * if a suitable Log instance cannot be returned */ public Log getInstance(String name) throws LogConfigurationException { - Log instance = null; - // protect against concurrent access of loggerMap - synchronized (loggerMap) { - instance = (Log) loggerMap.get(name); - if (instance == null) { + Log instance = (Log) loggerMap.get(name); + if (instance != null) { + return instance; + } else { + Log newInstance; - Logger logger = LoggerFactory.getLogger(name); + Logger logger = LoggerFactory.getLogger(name); - if(logger instanceof LocationAwareLogger) { + if (logger instanceof LocationAwareLogger) { - instance = new SLF4JLocationAwareLog((LocationAwareLogger) logger); + newInstance = new SLF4JLocationAwareLog((LocationAwareLogger) logger); - } else { + } else { - instance = new SLF4JLog(logger); + newInstance = new SLF4JLog(logger); - } + } - loggerMap.put(name, instance); + instance = (Log) loggerMap.putIfAbsent(name, newInstance); + return instance != null ? instance : newInstance; - } + } - } - return (instance); - } /** \ No newline at end of file Index: slf4j-jdk14/src/main/java/org/slf4j/impl/JDK14LoggerFactory.java IDEA additional info: Subsystem: com.intellij.openapi.diff.impl.patch.CharsetEP <+>windows-1252 =================================================================== --- slf4j-jdk14/src/main/java/org/slf4j/impl/JDK14LoggerFactory.java (revision 730ca751a9e7e30f0dc8025ebb57f15507ff0d4e) +++ slf4j-jdk14/src/main/java/org/slf4j/impl/JDK14LoggerFactory.java (revision ) @@ -27,22 +27,22 @@ import org.slf4j.Logger; import org.slf4j.ILoggerFactory; -import java.util.HashMap; -import java.util.Map; +import java.util.concurrent.ConcurrentHashMap; +import java.util.concurrent.ConcurrentMap; /** * JDK14LoggerFactory is an implementation of {@link ILoggerFactory} returning * the appropriately named {@link JDK14LoggerAdapter} instance. - * + * * @author Ceki Gülcü */ public class JDK14LoggerFactory implements ILoggerFactory { // key: name (String), value: a JDK14LoggerAdapter; - Map loggerMap; + ConcurrentMap loggerMap; public JDK14LoggerFactory() { - loggerMap = new HashMap(); + loggerMap = new ConcurrentHashMap(); } /* @@ -50,22 +50,21 @@ * * @see org.slf4j.ILoggerFactory#getLogger(java.lang.String) */ - public synchronized Logger getLogger(String name) { - Logger ulogger = null; - // protect against concurrent access of loggerMap - synchronized (this) { + public Logger getLogger(String name) { - // the root logger is called "" in JUL - if(name.equalsIgnoreCase(Logger.ROOT_LOGGER_NAME)) { - name = ""; - } + // the root logger is called "" in JUL + if(name.equalsIgnoreCase(Logger.ROOT_LOGGER_NAME)) { + name = ""; + } - ulogger = (Logger) loggerMap.get(name); - if (ulogger == null) { + + Logger ulogger = (Logger) loggerMap.get(name); + if (ulogger != null) { + return ulogger; + } else { - java.util.logging.Logger logger = java.util.logging.Logger + java.util.logging.Logger logger = java.util.logging.Logger .getLogger(name); - ulogger = new JDK14LoggerAdapter(logger); - loggerMap.put(name, ulogger); + Logger newInstance = new JDK14LoggerAdapter(logger); + ulogger = (Logger) loggerMap.putIfAbsent(name, newInstance); + return ulogger != null ? ulogger : newInstance; - } + } - } - return ulogger; } } Index: slf4j-simple/src/main/java/org/slf4j/impl/SimpleLoggerFactory.java IDEA additional info: Subsystem: com.intellij.openapi.diff.impl.patch.CharsetEP <+>windows-1252 =================================================================== --- slf4j-simple/src/main/java/org/slf4j/impl/SimpleLoggerFactory.java (revision 730ca751a9e7e30f0dc8025ebb57f15507ff0d4e) +++ slf4j-simple/src/main/java/org/slf4j/impl/SimpleLoggerFactory.java (revision ) @@ -24,8 +24,8 @@ */ package org.slf4j.impl; -import java.util.HashMap; -import java.util.Map; +import java.util.concurrent.ConcurrentHashMap; +import java.util.concurrent.ConcurrentMap; import org.slf4j.Logger; import org.slf4j.ILoggerFactory; @@ -38,26 +38,24 @@ */ public class SimpleLoggerFactory implements ILoggerFactory { - Map loggerMap; + ConcurrentMap loggerMap; public SimpleLoggerFactory() { - loggerMap = new HashMap(); + loggerMap = new ConcurrentHashMap(); } /** * Return an appropriate {@link SimpleLogger} instance by name. */ public Logger getLogger(String name) { - Logger slogger = null; - // protect against concurrent access of the loggerMap - synchronized (this) { - slogger = (Logger) loggerMap.get(name); - if (slogger == null) { - slogger = new SimpleLogger(name); - loggerMap.put(name, slogger); - } - } + Logger slogger = (Logger) loggerMap.get(name); + if (slogger != null) { - return slogger; + return slogger; + } else { + Logger newInstance = new SimpleLogger(name); + slogger = (Logger) loggerMap.putIfAbsent(name, newInstance); + return slogger != null ? slogger : newInstance; + } } /** Index: slf4j-log4j12/src/main/java/org/slf4j/impl/Log4jLoggerFactory.java IDEA additional info: Subsystem: com.intellij.openapi.diff.impl.patch.CharsetEP <+>windows-1252 =================================================================== --- slf4j-log4j12/src/main/java/org/slf4j/impl/Log4jLoggerFactory.java (revision 730ca751a9e7e30f0dc8025ebb57f15507ff0d4e) +++ slf4j-log4j12/src/main/java/org/slf4j/impl/Log4jLoggerFactory.java (revision ) @@ -24,8 +24,8 @@ */ package org.slf4j.impl; -import java.util.HashMap; -import java.util.Map; +import java.util.concurrent.ConcurrentHashMap; +import java.util.concurrent.ConcurrentMap; import org.apache.log4j.LogManager; import org.slf4j.ILoggerFactory; @@ -34,39 +34,37 @@ /** * Log4jLoggerFactory is an implementation of {@link ILoggerFactory} returning * the appropriate named {@link Log4jLoggerAdapter} instance. - * + * * @author Ceki Gülcü */ public class Log4jLoggerFactory implements ILoggerFactory { // key: name (String), value: a Log4jLoggerAdapter; - Map loggerMap; + ConcurrentMap loggerMap; public Log4jLoggerFactory() { - loggerMap = new HashMap(); + loggerMap = new ConcurrentHashMap(); } /* * (non-Javadoc) - * + * * @see org.slf4j.ILoggerFactory#getLogger(java.lang.String) */ public Logger getLogger(String name) { - Logger slf4jLogger = null; - // protect against concurrent access of loggerMap - synchronized (this) { - slf4jLogger = (Logger) loggerMap.get(name); - if (slf4jLogger == null) { + Logger slf4jLogger = (Logger) loggerMap.get(name); + if (slf4jLogger != null) { + return slf4jLogger; + } else { - org.apache.log4j.Logger log4jLogger; - if(name.equalsIgnoreCase(Logger.ROOT_LOGGER_NAME)) { - log4jLogger = LogManager.getRootLogger(); - } else { - log4jLogger = LogManager.getLogger(name); - } + org.apache.log4j.Logger log4jLogger; + if(name.equalsIgnoreCase(Logger.ROOT_LOGGER_NAME)) { + log4jLogger = LogManager.getRootLogger(); + } else { + log4jLogger = LogManager.getLogger(name); + } - slf4jLogger = new Log4jLoggerAdapter(log4jLogger); - loggerMap.put(name, slf4jLogger); + Logger newInstance = new Log4jLoggerAdapter(log4jLogger); + slf4jLogger = (Logger) loggerMap.putIfAbsent(name, newInstance); + return slf4jLogger != null ? slf4jLogger : newInstance; - } + } - } - return slf4jLogger; } } Index: slf4j-jcl/src/main/java/org/slf4j/impl/JCLLoggerFactory.java IDEA additional info: Subsystem: com.intellij.openapi.diff.impl.patch.CharsetEP <+>windows-1252 =================================================================== --- slf4j-jcl/src/main/java/org/slf4j/impl/JCLLoggerFactory.java (revision 730ca751a9e7e30f0dc8025ebb57f15507ff0d4e) +++ slf4j-jcl/src/main/java/org/slf4j/impl/JCLLoggerFactory.java (revision ) @@ -24,8 +24,8 @@ */ package org.slf4j.impl; -import java.util.HashMap; -import java.util.Map; +import java.util.concurrent.ConcurrentHashMap; +import java.util.concurrent.ConcurrentMap; import org.apache.commons.logging.LogFactory; import org.slf4j.ILoggerFactory; @@ -35,7 +35,7 @@ /** * JCLLoggerFactory is an implementation of {@link ILoggerFactory} returning the * appropriately named {@link JCLLoggerAdapter} instance. - * + * * @author Ceki Gülcü */ public class JCLLoggerFactory implements ILoggerFactory { @@ -59,10 +59,10 @@ } // key: name (String), value: a JCLLoggerAdapter; - Map loggerMap; + ConcurrentMap loggerMap; public JCLLoggerFactory() { - loggerMap = new HashMap(); + loggerMap = new ConcurrentHashMap(); } /* @@ -71,16 +71,14 @@ * @see org.slf4j.ILoggerFactory#getLogger(java.lang.String) */ public Logger getLogger(String name) { - Logger logger = null; - // protect against concurrent access of loggerMap - synchronized (this) { - logger = (Logger) loggerMap.get(name); - if (logger == null) { + Logger logger = (Logger) loggerMap.get(name); + if (logger != null) { + return logger; + } else { - org.apache.commons.logging.Log jclLogger = LogFactory.getLog(name); + org.apache.commons.logging.Log jclLogger = LogFactory.getLog(name); - logger = new JCLLoggerAdapter(jclLogger, name); - loggerMap.put(name, logger); + Logger newInstance = new JCLLoggerAdapter(jclLogger, name); + logger = (Logger) loggerMap.putIfAbsent(name, newInstance); + return logger != null ? logger : newInstance; - } + } - } - return logger; } }