Feedback request for a Single Instance Application Implementation

Question

Hello,
I have been working on a class which I tried to make the most generic I could so that I could re-use it for various projects. It offers 2 main functionalities:
-Preventing multiple instances of an application
-Allowing a user to stop the application even if it doesn't read any user input
Of course if someone wants to have multiple instances of the same application, it is still possible. The only requirement is that each instance be configured to run on a different port.
I would like your feedback on how I've implemented this to make sure I haven't missed the chance to make my Class flexible and re-usable. I would also make sure that there aren't any situations where the different threads used for realizing this functionality will run into any conflicts.
My code includes the following files:
Serviceable.java : An interface which must be implemented by every application using these classes
DuplicateServiceException.java : An exception thrown when an instance of the application is already running
Service.java : The class responsible for offering the functionalities I already mentionned
Main.java : An example of a class implementing Serviceable and offering two ways of closing the Application. 1- By closing the JFrame which is displayed. 2- By sending the stop command.
In order to execute this example, you have to specify the following command line arguments:
-DService.Command={start/stop} //Either start or stop command
-DService.Port=<0-65535> //Port to be used for receiving the stop command and preventing multiple instances
Serviceable.java
* Serviceable cares about two parts of the life of a Service.  Its startup
* and its shutdown sequences.  The startup occurs only after making sure
* no other instance of the Service is running.  Shutdown has to be
* synchronized between multiple threads since it is possible to shutdown
* the service through a shutdown command sent by another process, or through
* the normal flow of execution of the service.
* @author Gabriel Aubut-Lussier
public interface Serviceable {
      * Initiates the startup of the Service since we have made sure
      * that there isn't any other instance of the Service running.
     public void startup();
      * Initiates the shutdown of the Service since we've received
      * a shutdown request from one of the two supported means of
      * shutting down.
     public void shutdown();
DuplicateServiceException.java
public class DuplicateServiceException extends Exception {
      * serialVersionUID?  Bah. Eclipse generates one automatically so why not...
     private static final long serialVersionUID = 3929576386522489749L;
     public DuplicateServiceException() {
          super();
     public DuplicateServiceException(String msg) {
          super(msg);
Service.java
* The same way a graphical application is running as long as there
* is something to display, a background service will run as long as
* there is an active Thread.
* A service can be terminated in different ways.  First of all, it
* can be terminated through its normal flow of execution.  On the
* other hand, it is possible to provoke the termination of a Service
* externally.
* To terminate the service through the normal flow, just call the
* Service.shutdown() method.  Another way to terminate the service
* is to start a new instance of the program with the Stop command.
* This Service implementation will behave according to two system
* properties.  The property Service.Command can be set
* to "start" or "stop".  When set to "start", the Service will make
* sure there isn't another instance of the service already running.
* If it is the case, a DuplicateServiceException will be thrown.  In
* the other case, the Service will start.  When the "stop" command
* is invoked, the Service will attempt to stop a running instance of
* the Service.  The other property is Service.Port and
* it defines the Port number which will be used to support the
* functionalities offered by the Service class.
* It is recommended to set these properties as command line arguments
* when launching the application.  Moreover, batch files or shell
* scripts can be created for invoking the start and stop commands.
* @author Gabriel Aubut-Lussier
public class Service implements Runnable {
     public final static String START_COMMAND = "start";
     public final static String STOP_COMMAND = "stop";
     public final static String SERVICE_COMMAND = "Service.Command";
     public final static String SERVICE_PORT = "Service.Port";
     private String serviceCommand;
     private int servicePort;
     private Serviceable service;
     private ServerSocket serviceListener;
     private Thread serviceThread;
      * Creates a new service registering the hooks required to perform
      * clean termination sequences.
      * @param s
      * @throws DuplicateServiceException
     public Service(Serviceable s) throws DuplicateServiceException {
          service = s;
          serviceCommand = System.getProperty(SERVICE_COMMAND);
          String servicePortString = System.getProperty(SERVICE_PORT);
          if(servicePortString == null)
               servicePort = -1;
          else
               servicePort = Integer.parseInt(servicePortString);
      * Try running this new Service instance if there isn't one
      * already running.
      * @throws DuplicateServiceException if another service instance is already running.
     public void start() throws DuplicateServiceException {
          if(serviceCommand == null || servicePort < 0) {
               throw new IllegalArgumentException("The command and port number must be specified.");
          if(serviceCommand.equals(START_COMMAND)) {
               try {
                    serviceListener = new ServerSocket(servicePort);
                    serviceThread = new Thread(this);
                    serviceThread.start();
                    service.startup();
               } catch(BindException e) {
                    throw new DuplicateServiceException("An instance of the service is already running.");
               }catch(IOException e) {
                    e.printStackTrace();
          } else if(serviceCommand.equals(STOP_COMMAND)) {
               shutdown();
      * Provoke a shutdown command.
     public void shutdown() {
          try {
               Socket sock = new Socket("localhost", servicePort);
               OutputStreamWriter out = new OutputStreamWriter(sock.getOutputStream());
               out.write("shutdown");
               out.flush();
               out.close();
               sock.close();
          } catch (UnknownHostException e) {
               e.printStackTrace();
          } catch (IOException e) {
               //This exception may occur when trying to stop a service which wasn't running.
               //There is no need to do anything in this case.
      * While the Service is running, it listens on a port to make sure no
      * other instance of this Service is started and to listen to shutdown
      * commands.
     public void run() {
          boolean keepGoing = true;
          while(keepGoing) {
               try {
                    Socket sock = serviceListener.accept();
                    InputStreamReader in = new InputStreamReader(sock.getInputStream());
                    char cBuf[] = new char[256];
                    int amount = in.read(cBuf);
                    in.close();
                    sock.close();
                    keepGoing = !((new String(cBuf, 0, amount)).equals("shutdown"));
               } catch (IOException e) {
                    e.printStackTrace();
          try {
               service.shutdown();
               serviceListener.close();
          } catch(IOException e) {
               e.printStackTrace();
     public String getServiceCommand() {
          return serviceCommand;
     public void setServiceCommand(String serviceCommand) {
          this.serviceCommand = serviceCommand;
     public int getServicePort() {
          return servicePort;
     public void setServicePort(int servicePort) {
          this.servicePort = servicePort;
Main.java
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import javax.swing.JFrame;
public class Main implements Serviceable {
     private JFrame window;
     private Service service;
     public static void main(String[] args) {
          new Main();
     public Main() {
          try {
               service = new Service(this);
               service.start();
          } catch(DuplicateServiceException e) {
               e.printStackTrace();
     public void startup() {
          window = new JFrame("SERVICE TEST! :D");
          window.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
          window.addWindowListener(new WindowAdapter() {
               public void windowClosed(WindowEvent e) {
                    service.shutdown();
          window.setVisible(true);
     public void shutdown() {
          System.out.println("Application shutdown");
          window.dispose();
}Thanks in advance for your feedback.
-Gabriel Aubut-Lussier

Answer 1

I have fixed the handshake.
And even though it isn't implemented yet, I think I have my solution for the limitation of 1 instance per user. I plan on using a hidden file in the user's home directory in which I will write the port number where the running application is listening for events. I have not yet chosen how the port number will be chosen before being written to the file but I am thinking about using a random number between 1024 and 65535. Using this approach, it is possible to maintain all the features I've implemented in the Single Overall Instance solution I already have.
Here is the code with the handshake fixed:
Serviceable.java
* Serviceable cares about two parts of the life of a Service.  Its startup
* and its shutdown sequences.  The startup occurs only after making sure
* no other instance of the Service is running.  Shutdown has to be
* synchronized between multiple threads since it is possible to shutdown
* the service through a shutdown command sent by another process, or through
* the normal flow of execution of the service.  Moreover, when another instance
* is prevented from being launched, the running instance is notified so that it
* can react to such an event.
* @author Gabriel Aubut-Lussier
public interface Serviceable {
      * Initiates the startup of the Service since we have made sure
      * that there isn't any other instance of the Service running.
     public void startup();
      * Notifies the Service that the application has been invoked again in
      * case the running instance wants to react to such an event.  Most GUI
      * applications will just bring themselves to the front while background
      * services will maybe just want to re-scan their configuration files or
      * just ignore the event.
     public void invoke();
      * Initiates the shutdown of the Service since we've received
      * a shutdown request from one of the two supported means of
      * shutting down.
     public void shutdown();
DuplicateInstanceException.java
public class DuplicateServiceException extends Exception {
      * serialVersionUID?  Bah. Eclipse generates one automatically so why not...
     private static final long serialVersionUID = 3929576386522489749L;
     public DuplicateServiceException() {
          super();
     public DuplicateServiceException(String msg) {
          super(msg);
Service.java
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.BindException;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.UnknownHostException;
* The same way a graphical application is running as long as there
* is something to display, a background service will run as long as
* there is an active Thread.
* A service can be terminated in different ways.  First of all, it
* can be terminated through its normal flow of execution.  On the
* other hand, it is possible to provoke the termination of a Service
* externally.
* To terminate the service through the normal flow, just call the
* Service.shutdown() method.  Another way to terminate the service
* is to start a new instance of the program with the Stop command.
* This Service implementation will behave according to two system
* properties.  The property Service.Command can be set to "start"
* or "stop".  When set to "start", the Service will make sure there
* isn't another instance of the service already running.  If it is
* the case, a DuplicateServiceException will be thrown.  In the
* other case, the Service will start.  When the "stop" command is
* invoked, the Service will attempt to stop a running instance of
* the Service.  The other property is Service.Port and it defines
* the Port number which will be used to support the functionalities
* offered by the Service class.
* It is recommended to set these properties as command line arguments
* when launching the application.  Moreover, batch files or shell
* scripts can be created for invoking the start and stop commands.
* @author Gabriel Aubut-Lussier
public class Service implements Runnable {
     public final static String START_COMMAND = "start";
     public final static String STOP_COMMAND = "stop";
     public final static String SERVICE_COMMAND = "Service.Command";
     public final static String SERVICE_PORT = "Service.Port";
     private final static String GREETING = "Greetings";
     private final static String QUERY = "?";
     private final static String ACCEPT = "yes";
     private final static String DECLINE = "no";
     private final static String SHUTDOWN = "shutdown ";
     private final static int SO_TIMEOUT = 100;
      * This is the application-specific String
     private String serviceClass;
      * This is the command which we will execute when start() is invoked
      * The value is either "start" or "stop"
      * This value can be configured using the System property: Service.Command
     private String serviceCommand;
      * This is the port which is used to watch for duplicate instances
      * This value can be configured using the System property: Service.Port
     private int servicePort;
     private Serviceable service;
     private ServerSocket serviceListener;
     private Thread serviceThread;
      * Creates a new service registering the hooks required to perform
      * clean termination sequences.
      * @param s A Serviceable class
      * @throws DuplicateServiceException If there is a duplicate instance running
     public Service(Serviceable s) throws DuplicateServiceException {
          service = s;
          serviceClass = s.getClass().toString();
          serviceCommand = System.getProperty(SERVICE_COMMAND);
          String servicePortString = System.getProperty(SERVICE_PORT);
          if(servicePortString == null)
               servicePort = -1;
          else
               servicePort = Integer.parseInt(servicePortString);
      * Try running this new Service instance if there isn't one
      * already running.
      * @throws DuplicateServiceException if another service instance is already running.
      * @throws BindException if another application is using the configured port.
     public void start() throws DuplicateServiceException, BindException {
          if(serviceCommand == null || servicePort < 0 || servicePort > 65535) {
               throw new IllegalArgumentException("The command and port number must be specified.");
          if(serviceCommand.equals(START_COMMAND)) {
               try {
                    serviceListener = new ServerSocket(servicePort);
                    serviceThread = new Thread(this);
                    serviceThread.start();
                    service.startup();
               } catch(BindException e) {
                    queryOtherInstance();
                    throw e;
               } catch(IOException e) {
                    e.printStackTrace();
          } else if(serviceCommand.equals(STOP_COMMAND)) {
               shutdown();
      * Send the shutdown command to the running instance of the application.
     public boolean shutdown() {
          boolean shutdownSuccessful = false;
          try {
               Socket sock = new Socket("localhost", servicePort);
               sock.setSoTimeout(SO_TIMEOUT);
               //If the greeting doesn't match, it's not a duplicate instance
               //and we can't shut it down
               InputStreamReader in = new InputStreamReader(sock.getInputStream());
               OutputStreamWriter out;
               if(receivedGreeting(in)) {
                    //Sending the shutdown command
                    out = new OutputStreamWriter(sock.getOutputStream());
                    out.write(SHUTDOWN + serviceClass);
                    out.flush();
                    //Read the confirmation
                    char cBuf[] = new char[1024];
                    int amount = in.read(cBuf);
                    String confirmation = new String(cBuf, 0, amount);
                    if(confirmation.equals(ACCEPT)) {
                         shutdownSuccessful = true;
                    out.close();
               //Closing the connection
               in.close();
               sock.close();
          } catch (UnknownHostException e) {
               //This exception shouldn't happen unless the loopback address doesn't exist?
          } catch (IOException e) {
               //This exception may occur when trying to stop a service which wasn't running.
               //There is no need to do anything in this case.
          return shutdownSuccessful;
      * Reads the greeting from the running instance we are interacting with.
      * @param in An InputStreamReader built on the Socket's InputStream
      * @return True if we received the expected greeting, false otherwise
      * @throws IOException if a problem occurs while receiving the greeting
     private boolean receivedGreeting(InputStreamReader in) throws IOException {
          //Reading the expected greeting from the server
          char cBuf[] = new char[1024];
          int amount = in.read(cBuf);
          String greeting = new String(cBuf, 0, amount);
          return greeting.equals(GREETING);
      * While the Service is running, it listens on a port to make sure no
      * other instance of this Service is started and to listen to shutdown
      * commands.
     public void run() {
          boolean keepGoing = true;
          while(keepGoing) {
               Socket sock;
               InputStreamReader in;
               try {
                    sock = serviceListener.accept();
                    sock.setSoTimeout(SO_TIMEOUT);
                    //Sending a greeting
                    OutputStreamWriter out = new OutputStreamWriter(sock.getOutputStream());
                    out.write(GREETING);
                    out.flush();
                    //Reading the incoming message
                    in = new InputStreamReader(sock.getInputStream());
                    char cBuf[] = new char[1024];
                    int amount = in.read(cBuf);
                    String message = new String(cBuf, 0, amount);
                    //Writing an answer
                    boolean invoked = message.equals(serviceClass + QUERY);
                    if(invoked) {
                         out.write(ACCEPT);
                    } else {
                         out.write(DECLINE);
                         keepGoing = !message.equals(SHUTDOWN + serviceClass);
                    out.flush();
                    //Closing the connection
                    out.close();
                    in.close();
                    sock.close();
                    //Notify the running application is there has been an invocation
                    if(invoked) {
                         service.invoke();
               } catch (IOException e) {
                    //Seems like an IO operation failed.  Let's just forget about
                    //this connection attempt and wait for another
          //Shutdown the Service
          service.shutdown();
          try {
               serviceListener.close();
          } catch(IOException e) {
               //Couldn't close the serverSocket upon shutdown?
               //weird... but anyhow...
      * Connects to the configured port to check out wether it is a duplicate
      * instance of the application or if it is another application using the
      * same port number.  If it is another application, nothing will happen.
      * @throws DuplicateServiceException if it is a duplicate instance
     private void queryOtherInstance() throws DuplicateServiceException {
          try {
               Socket sock = new Socket("localhost", servicePort);
               sock.setSoTimeout(SO_TIMEOUT);
               //Read greeting
               InputStreamReader in = new InputStreamReader(sock.getInputStream());
               String answer = null;
               if(receivedGreeting(in)) {
                    //Writing the application-specific query
                    OutputStreamWriter out = new OutputStreamWriter(sock.getOutputStream());
                    out.write(service.getClass().toString() + "?");
                    out.flush();
                    //Reading the answer
                    char[] cBuf = new char[3];
                    int amount = in.read(cBuf);
                    answer = new String(cBuf, 0, amount);
                    out.close();
               //Closing the connection
               in.close();
               sock.close();
               //If the answer is "yes" then it is a duplicate
               if(answer != null && answer.equals("yes")) {
                    throw new DuplicateServiceException("An instance of the service is already running.");
          } catch (UnknownHostException e) {
               //This exception shouldn't happen unless the loopback address doesn't exist?
          } catch (IOException e) {
               //If we fail to query the application appropriately we consider
               //it isn't a duplicate entry so we do nothing.
     public String getServiceCommand() {
          return serviceCommand;
     public void setServiceCommand(String serviceCommand) {
          this.serviceCommand = serviceCommand;
     public int getServicePort() {
          return servicePort;
     public void setServicePort(int servicePort) {
          this.servicePort = servicePort;
Main.java
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.net.BindException;
import javax.swing.JFrame;
public class Main implements Serviceable {
     private JFrame window;
     private Service service;
     public static void main(String[] args) {
          new Main();
     public Main() {
          try {
               service = new Service(this);
               service.start();
          } catch(DuplicateServiceException e) {
               e.printStackTrace();
          } catch(BindException e) {
               e.printStackTrace();
     public void startup() {
          window = new JFrame("SERVICE TEST! :D");
          window.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
          window.addWindowListener(new WindowAdapter() {
               public void windowClosed(WindowEvent e) {
                    service.shutdown();
          window.setVisible(true);
     public void shutdown() {
          System.out.println("Application shutdown");
          window.dispose();
     public void invoke() {
          System.out.println("Another instance tried to startup");
          window.toFront();
}