While Executor on its own is a great addition to Java, there are times when you need more control over how execution occurs, when it stops, and even how it stops. For all of these cases, ExecutorService should be used.
If you take a close look at the factory method signatures for Executors, you'll note that each returns an ExecutorService, rather than an Executor. java.util.concurrent.ExecutorService is a subinterface of Executor, and adds a good deal of functionality to the simple execute( ) method you saw in "Separating Thread Logic From Execution." Two of these are key in allowing you to stop an ExecutorService, either for an error condition or in a normal shutdown situation:
NOTE
This isn't a fully (or even partially) functional FTP server, and is just used for example purposes. You won't find it in the sample code, as it doesn't actually work.
public class FtpServer {
private ExecutorService service;
public FtpServer(int port) throws IOException {
openSocket(port);
service = Executors.newFixedThreadPool(100);
}
public void go( ) {
try {
while (true) {
service.execute(new FtpHandler(getSocket( )));
}
} catch (Exception e) {
service.shutdownNow( );
}
}
public void stop( ) {
try {
service.shutdown( );
} catch (Exception e) {
// report problem
}
}
}
class FtpHandler implements Runnable {
private Socket socket;
public FtpHandler(Socket socket) {
this.socket = socket;
}
public void run( ) {
// Handle connection
}
}
NOTE
Basically, getSocket( ) would wait for a client to connect, and return the connection to that client as a Socket object.
This little pseudo-class primarily illustrates two methods:
This method stop the service, but first allows the service to attempt to complete all running and queued tasks. No new tasks are accepted after this call, though.
A little more direct, this method stops the service, and does not allow any queued or running tasks to execute. Currently running tasks are basically tossed, and queued tasks are returned via a List<Runnable>, for program use (if desiredin the example, I ignored these completely).
You can choose whichever of these suits you, based on your application needs. There's one other big advantage of using ExecutorService, which the next lab, Using Callable Objects, looks at in detail.