Logger disabled in shutdown hook thread

Question

Hi, all,
In a shutdown hook thread, i want to keep a log using jdk1.4's logging class as following:
public void run(){
synchronized(this){
logger.info("System Shutdown");
But the logger does not work. Does anybody have the idea?
I create the logger with the following:
FileHandler fh = new FileHandler("MyLog.log");
fh.setFormatter(new CCXmlFormatter());
logger=Logger.getLogger("MyLog");
logger.addHandler(fh);

Answer 1

Please accept my appology for the off subject materiel. I just finished writing this and do not want to edit...
There is a design problem in the MemoryHandler class in that the close() method does not invoke push() as might be expected because most close() methods do flush buffers. This problem is exacerbated by the fact that LogManager registers a shutdown hook that closes all handlers. The log manager shutdown hook also does not invoke push() for memory handlers. Thus it is incumbent upon the user to invoke push() prior to shutting down. It would be natural to do this in a shutdown hook inside of a configureLogger() method. For example,
private static Logger configureLogger() {
Logger logger = Logger.getLogger("com.javarules");
logger.setLevel(Level.ALL);
try {
target =new FileHandler("%t/javarules.log",20000,1);
target.setFormatter(new SimpleFormatter());
} catch(IOException e) {
e.printStackTrace();
System.exit(1);
memoryHandler = new MemoryHandler(target,
2000,
Level.SEVERE);
Runtime.getRuntime().addShutdownHook(new Thread() {
public void run() {
memoryHandler.push();
logger.addHandler(memoryHandler);
logger.setUseParentHandlers(false);
return logger;
The problem with this is that shutdown hooks are a bunch of unstarted threads that the JVM runs concurrently. There is no guarantee this shutdown hook will run before the log manager closes the handler. (In my experience, the log manager shutdown hook runs first most of the time.)
Closing a memory handler does two things. The target handler is closed and the memory handler level is set to OFF, which means that when your shutdown hook runs, nothing is published and the push() method completes normally. In single-threaded applications memory-Handler.push() can be invoked at the bottom of the main method. GUI applications should invoke it in AWTExceptionHandler (or whatever you call your top-level exception handler) as well as the windowClosing (WindowEvent e) method.
There is actually a larger design issue than not being able to invoke push() in a shutdown hook. Should the LogManager class be registering a shutdown hook that invokes reset()? The API docs for that method read as follows.
Reset the logging configuration.
For all named loggers, the reset operation
removes and closes all Handlers and (except
for the root logger) sets the level to null.
The root logger's level is set to Level.INFO.
Bug Id 4682478 addresses this question, but misses the mark because it suggests an ordering (or reordering) of shutdown hooks. The evaluation correctly notes that it �is dangerous to rely on ordering of shutdown operations.� As noted above, shutdown hooks are a bunch of unstarted threads that a JVM starts and runs concurrently. They are not and never will be ordered. See java.sun.com/j2se/1.3/docs/guide/lang/hook-design.html for a discussion. The question, however, is not the fact that shutdown hooks are unordered. The question is should the log manager be closing handlers. In other words, should LogManager be registering a shutdown hook at all? If the answer is yes, the only plausible explanation is the push() method in a memory handler, which explains why I began this section with a discussion of that method. There is no documentation to support this theory (which in and of itself is a problem), but it is at least possible that the Cleaner thread (which is the name of the shutdown hook registered in LogManager) is designed precisely so that application programmers would not use the logging API in a shutdown hook. Logging one or two messages in a shutdown hook would not be a problem, but invoking push() for a memory handler that has thousands of log records that must be both localized and formatted could be a problem. As noted in the addShutdownHook(Thread hook) method:
Shutdown hooks should... finish their work
quickly. When a program invokes exit the
expectation is that the virtual machine will
promptly shut down and exit. When the virtual
machine is terminated due to user logoff or
system shutdown the underlying operating
system may only allow a fixed amount of time
in which to shut down and exit. It is there-
fore inadvisable to attempt any user
interaction or to perform a long-running
computation in a shutdown hook.
I think this warning should suffice, however, and that the logging API should be usable in a shutdown hook. At a bare minimum the LogManager class should document the rationale for making the logging API unavailable during shutdown.