jdk-sandbox: comparison jdk/src/java.logging/share/classes/java/util/logging/LogManager.java

equal deleted inserted replaced

-:d9891f85d583
+:1fcf87dbdc3c
 import java.security.*;
 import java.lang.ref.ReferenceQueue;
 import java.lang.ref.WeakReference;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.locks.ReentrantLock;
 import sun.misc.JavaAWTAccess;
 import sun.misc.ManagedLocalsThread;
 import sun.misc.SharedSecrets;
 /**
 // Have we done the primordial reading of the configuration file?
 // (Must be done after a suitable amount of java.lang.System
 // initialization has been done)
 private volatile boolean readPrimordialConfiguration;
 // Have we initialized global (root) handlers yet?
-// This gets set to false in readConfiguration
+// This gets set to STATE_UNINITIALIZED in readConfiguration
-private boolean initializedGlobalHandlers = true;
+private static final int
-// True if JVM death is imminent and the exit hook has been called.
+STATE_INITIALIZED = 0, // initial state
-private boolean deathImminent;
+STATE_INITIALIZING = 1,
+STATE_READING_CONFIG = 2,
+STATE_UNINITIALIZED = 3,
+STATE_SHUTDOWN = 4;    // terminal state
+private volatile int globalHandlersState; // = STATE_INITIALIZED;
+// A concurrency lock for reset(), readConfiguration() and Cleaner.
+private final ReentrantLock configurationLock = new ReentrantLock();
 // This list contains the loggers for which some handlers have been
 // explicitly configured in the configuration file.
 // It prevents these loggers from being arbitrarily garbage collected.
 private static final class CloseOnReset {
 public void run() {
 // This is to ensure the LogManager.<clinit> is completed
 // before synchronized block. Otherwise deadlocks are possible.
 LogManager mgr = manager;
-// If the global handlers haven't been initialized yet, we
+// set globalHandlersState to STATE_SHUTDOWN atomically so that
-// don't want to initialize them just so we can close them!
+// no attempts are made to (re)initialize the handlers or (re)read
-synchronized (LogManager.this) {
+// the configuration again. This is terminal state.
-// Note that death is imminent.
+configurationLock.lock();
-deathImminent = true;
+globalHandlersState = STATE_SHUTDOWN;
-initializedGlobalHandlers = true;
+configurationLock.unlock();
-}
 // Do a reset to close all active handlers.
 reset();
 }
 }
 *             the caller does not have LoggingPermission("control").
 */
 public void reset() throws SecurityException {
 checkPermission();
 List<CloseOnReset> persistent;
-synchronized (this) {
+// We don't want reset() and readConfiguration()
+// to run in parallel
+configurationLock.lock();
+try {
+// install new empty properties
 props = new Properties();
 // make sure we keep the loggers persistent until reset is done.
 // Those are the loggers for which we previously created a
 // handler from the configuration, and we need to prevent them
 // from being gc'ed until those handlers are closed.
 persistent = new ArrayList<>(closeOnResetLoggers);
 closeOnResetLoggers.clear();
-// Since we are doing a reset we no longer want to initialize
-// the global handlers, if they haven't been initialized yet.
+// if reset has been called from shutdown-hook (Cleaner),
-initializedGlobalHandlers = true;
+// or if reset has been called from readConfiguration() which
-}
+// already holds the lock and will change the state itself,
-for (LoggerContext cx : contexts()) {
+// then do not change state here...
-Enumeration<String> enum_ = cx.getLoggerNames();
+if (globalHandlersState != STATE_SHUTDOWN &&
-while (enum_.hasMoreElements()) {
+globalHandlersState != STATE_READING_CONFIG) {
-String name = enum_.nextElement();
+// ...else user called reset()...
-Logger logger = cx.findLogger(name);
+// Since we are doing a reset we no longer want to initialize
-if (logger != null) {
+// the global handlers, if they haven't been initialized yet.
-resetLogger(logger);
+globalHandlersState = STATE_INITIALIZED;
 }
-}
-}
+for (LoggerContext cx : contexts()) {
-persistent.clear();
+resetLoggerContext(cx);
 }
-// Private method to reset an individual target logger.
+persistent.clear();
-private void resetLogger(Logger logger) {
+} finally {
-// Close all the Logger's handlers.
+configurationLock.unlock();
+}
+}
+private void resetLoggerContext(LoggerContext cx) {
+Enumeration<String> enum_ = cx.getLoggerNames();
+while (enum_.hasMoreElements()) {
+String name = enum_.nextElement();
+Logger logger = cx.findLogger(name);
+if (logger != null) {
+resetLogger(logger);
+}
+}
+}
+private void closeHandlers(Logger logger) {
 Handler[] targets = logger.getHandlers();
 for (Handler h : targets) {
 logger.removeHandler(h);
 try {
 h.close();
 } catch (Exception ex) {
 // Problems closing a handler?  Keep going...
 }
 }
+}
+// Private method to reset an individual target logger.
+private void resetLogger(Logger logger) {
+// Close all the Logger handlers.
+closeHandlers(logger);
+// Reset Logger level
 String name = logger.getName();
 if (name != null && name.equals("")) {
 // This is the root logger.
 logger.setLevel(defaultLevel);
 } else {
 *             the caller does not have LoggingPermission("control").
 * @exception  IOException if there are problems reading from the stream.
 */
 public void readConfiguration(InputStream ins) throws IOException, SecurityException {
 checkPermission();
-reset();
+// We don't want reset() and readConfiguration() to run
-// Load the properties
+// in parallel.
+configurationLock.lock();
 try {
-props.load(ins);
+if (globalHandlersState == STATE_SHUTDOWN) {
-} catch (IllegalArgumentException x) {
+// already in terminal state: don't even bother
-// props.load may throw an IllegalArgumentException if the stream
+// to read the configuration
-// contains malformed Unicode escape sequences.
+return;
-// We wrap that in an IOException as readConfiguration is
+}
-// specified to throw IOException if there are problems reading
-// from the stream.
+// change state to STATE_READING_CONFIG to signal reset() to not change it
-// Note: new IOException(x.getMessage(), x) allow us to get a more
+globalHandlersState = STATE_READING_CONFIG;
-// concise error message than new IOException(x);
-throw new IOException(x.getMessage(), x);
-}
-// Instantiate new configuration objects.
-String names[] = parseClassNames("config");
-for (String word : names) {
 try {
-Class<?> clz = ClassLoader.getSystemClassLoader().loadClass(word);
+// reset configuration which leaves globalHandlersState at STATE_READING_CONFIG
-clz.newInstance();
+// so that while reading configuration, any ongoing logging requests block and
-} catch (Exception ex) {
+// wait for the outcome (see the end of this try statement)
-System.err.println("Can't load config class \"" + word + "\"");
+reset();
-System.err.println("" + ex);
-// ex.printStackTrace();
+try {
-}
+// Load the properties
-}
+props.load(ins);
+} catch (IllegalArgumentException x) {
-// Set levels on any pre-existing loggers, based on the new properties.
+// props.load may throw an IllegalArgumentException if the stream
-setLevelsOnExistingLoggers();
+// contains malformed Unicode escape sequences.
+// We wrap that in an IOException as readConfiguration is
-try {
+// specified to throw IOException if there are problems reading
-invokeConfigurationListeners();
+// from the stream.
+// Note: new IOException(x.getMessage(), x) allow us to get a more
+// concise error message than new IOException(x);
+throw new IOException(x.getMessage(), x);
+}
+// Instantiate new configuration objects.
+String names[] = parseClassNames("config");
+for (String word : names) {
+try {
+Class<?> clz = ClassLoader.getSystemClassLoader().loadClass(word);
+clz.newInstance();
+} catch (Exception ex) {
+System.err.println("Can't load config class \"" + word + "\"");
+System.err.println("" + ex);
+// ex.printStackTrace();
+}
+}
+// Set levels on any pre-existing loggers, based on the new properties.
+setLevelsOnExistingLoggers();
+// Note that we need to reinitialize global handles when
+// they are first referenced.
+globalHandlersState = STATE_UNINITIALIZED;
+} catch (Throwable t) {
+// If there were any trouble, then set state to STATE_INITIALIZED
+// so that no global handlers reinitialization is performed on not fully
+// initialized configuration.
+globalHandlersState = STATE_INITIALIZED;
+// re-throw
+throw t;
+}
 } finally {
-// Note that we need to reinitialize global handles when
+configurationLock.unlock();
-// they are first referenced.
+}
-synchronized (this) {
-initializedGlobalHandlers = false;
+// should be called out of lock to avoid dead-lock situations
-}
+// when user code is involved
-}
+invokeConfigurationListeners();
 }
 /**
 * Get the value of a logging property.
 * The method returns null if the property is not found.
 }
 // Private method to load the global handlers.
 // We do the real work lazily, when the global handlers
 // are first used.
-private synchronized void initializeGlobalHandlers() {
+private void initializeGlobalHandlers() {
-if (initializedGlobalHandlers) {
+int state = globalHandlersState;
+if (state == STATE_INITIALIZED ||
+state == STATE_SHUTDOWN) {
+// Nothing to do: return.
 return;
 }
-initializedGlobalHandlers = true;
+// If we have not initialized global handlers yet (or need to
+// reinitialize them), lets do it now (this case is indicated by
-if (deathImminent) {
+// globalHandlersState == STATE_UNINITIALIZED).
-// Aaargh...
+// If we are in the process of initializing global handlers we
-// The VM is shutting down and our exit hook has been called.
+// also need to lock & wait (this case is indicated by
-// Avoid allocating global handlers.
+// globalHandlersState == STATE_INITIALIZING).
-return;
+// If we are in the process of reading configuration we also need to
-}
+// wait to see what the outcome will be (this case
-loadLoggerHandlers(rootLogger, null, "handlers");
+// is indicated by globalHandlersState == STATE_READING_CONFIG)
+// So in either case we need to wait for the lock.
+configurationLock.lock();
+try {
+if (globalHandlersState != STATE_UNINITIALIZED) {
+return; // recursive call or nothing to do
+}
+// set globalHandlersState to STATE_INITIALIZING first to avoid
+// getting an infinite recursion when loadLoggerHandlers(...)
+// is going to call addHandler(...)
+globalHandlersState = STATE_INITIALIZING;
+try {
+loadLoggerHandlers(rootLogger, null, "handlers");
+} finally {
+globalHandlersState = STATE_INITIALIZED;
+}
+} finally {
+configurationLock.unlock();
+}
 }
 static final Permission controlPermission = new LoggingPermission("control", null);
 void checkPermission() {
 }
 // Private method to be called when the configuration has
 // changed to apply any level settings to any pre-existing loggers.
-synchronized private void setLevelsOnExistingLoggers() {
+private void setLevelsOnExistingLoggers() {
 Enumeration<?> enum_ = props.propertyNames();
 while (enum_.hasMoreElements()) {
 String key = (String)enum_.nextElement();
 if (!key.endsWith(".level")) {
 // Not a level definition.

changeset 30643	1fcf87dbdc3c
parent 29919	be906afc335b
child 31150	2aa1d300cd75