Java：正确关闭多个线程

Question

I'm making a simple server that will spawn multiple threads to handle multiple clients. I was wondering the proper way to shut down and close all the various streams and threads when the server is terminated.

I added a shutdownHook that runs a method that tells the server to shutdown. The server, in turn, broadcasts the shutdown call to all of the threads it has opened, which sets a "isClosed" boolean in each thread to true.

What I'm expecting is that each thread, when reaching the end of the run() method and looping up again, hits the while(!isClosed) conditional, thereby properly terminating themselves by closing all the proper sockets/streams and returning.

However, I don't know if this will properly close everything since the program should terminate after the shutdownhook completes. It completes fairly early since all it does is propagate the closing message. Does this mean that some threads won't get enough time to properly close?

If so, would the best method be to have the shutdownhook manually close every thread, ensuring that they have closed, before returning?

Answer 1

Using an ExecutorService is the modern way of doing it. It takes so much of the fiddly bits away from the code.

Here is a good place to start.

Answer 2

You are correct that the threads will likely not have enough time to terminate properly if the server is terminated. However, depending on what you're trying to do, this may or may not be a problem. If there is no cleanup work needed, then you probably do not need to worry about it because having the threads abruptly terminate will cause no issues.

However, if there is cleanup work that needs to be done (such as writing to a database), then you need something else. The best way to do this (in Java) is using an Executor/ExecutorService and related items ( http://docs.oracle.com/javase/6/docs/api/java/util/concurrent/Executors.html ). Your problem is addressed well by these, plus you get some nice freebies such as thread pool management so that scaling is much easier. If you spawn a new thread for every client you will have big problems when you try to scale later because you can't be creating a million threads per minute, for example.

Using the Excecutor stuff is a bit of an adjustment if you're used to using raw threads, but it is worth the research. Good luck!

Answer 3

The shutdownHook happens too late in the the cycle to be useful that way. It is expected to complete quickly and the JVM is already on the way down, which could take existing threads with it if they are daemons.

I would just set a read timeout on the connection threads of say 15-30 seconds. If the timeout happens (SocketTimeoutException) , close the socket and exit the thread. The clients will have to cope with dropped connections of course, but they have to do that already. Then when you want to shutdown, just stop accepting new connections (eg close the ServerSocket and have its accept thread cope correctly with the resulting exception). When all the existing connection threads have exited, the JVM will exit, and that should really take no longer than the timeout period plus the length of the longest transaction. Make sure the connection threads aren't daemons.

If you don't mind clients getting chopped off in mid-transaction, just call System.exit().

Answer 4

Have you considered making your threads daemon threads. just add t.setdaemon(true); before calling the start method of the thread. If these threads should be ended when the program is ended than making them daemon will kill them once all the other non daemon thread has ended. threads that are used in threadpool are good example for threads that should be daemons. and i really think it can be useful for you.