How to ensure only one instance of a java program can be executed? [duplicate]

Answer 1

hi there are many way to do it , just visit this page. i just copy paste. also view this thread [stackoverflow][1]

One of the most asking question in java world is how to make java application as a single instance.

I google it and found many of the techniques. I am posted here some of popular techniques. Just go ahead and contact if you have problem......

1. By capturing port or through ServerSocket (short code) . On this method we are creating a object of java.net.ServerSocket class. And by passing a port number we are captured while first instance so that if another instance occurred it is throwing a bind Exception and you can tracked that any more instance is running on system.

Just see the link for code http://yuvadevelopers.dmon.com/java_examples/Single_Instance_small.htm

2. By capturing port or through ServerSocket (Big code). It is same as the first method but while google i got this big code with different option just go through the code.

Just see the link for code See the original source here get from google http://www.rbgrn.net/blog/2008/05/java-single-application-instance.html

3. By accessing file from local file system. This is also another method for doing the same thing. But it is not that much preferable because sometime when JVM crashes or due to some IO error occured then file is not deleted from hard disk. note:- Dont put your file (you can use any file) in C drive or where OS exist.
   Just see below for code

/*
* Program for setting single instance in JAVA
* Copyright 2009 @ yuvadeveloper
* Code By:- Prashant Chandrakar
*
*/
import java.net.ServerSocket;
import javax.swing.JOptionPane;
import javax.swing.JFrame;
import java.io.IOException;
import java.net.BindException;
class SingleInstance
{
  public static ServerSocket serverSocket;
  public static String errortype = "Access Error";
  public static String error = "Application already running.....";
  public static void main(String as[])
  {
    try
    {
        //creating object of server socket and bind to some port number serverSocket = new ServerSocket(15486);
        ////do not put common port number like 80 etc.
        ////Because they are already used by system
        JFrame jf = new JFrame();
        jf.setVisible(true);
        jf.setSize(200, 200);
     }
     catch (BindException exc)
     {
        JOptionPane.showMessageDialog(null, error, errortype, JOptionPane.ERROR_MESSAGE);
        System.exit(0);
     }
     catch (IOException exc)
     {
        JOptionPane.showMessageDialog(null, error, errortype, JOptionPane.ERROR_MESSAGE);
        System.exit(0);
     }
   }
}

4. By using java sun.jvmstat package from tools.jar.

Just see the link for code

5. By using Launch4j application. It is a third party tools for creating a EXE for your application. It is giving you a facility of creating single instance application. Just try it. It is perfect tool.

Just see the launch4j application doc http://launch4j.sourceforge.net/

Answer 2

The way it is often done in unix systems is to create a file, which is an atomic operation and then check whether the file could be created or not. If it was possible to create the file then that process has the lock and is allowed to run. If the file could not be created, someone else must have the lock and the instance terminates promptly. The code for such a thing

private boolean lock()
 {
   try
    {
        final File file=new File("bpmdj.lock");
        if (file.createNewFile())
        {
            file.deleteOnExit();
            return true;
        }
        return false;
    }
    catch (IOException e)
    {
        return false;
    }
}

in the main of the app you then start with

    if (!lock())
    {
        System.out.println("Cannot lock database. Check that no other instance of BpmDj is running and if so, delete the file bpmdj.lock");
        return;
    }

Of course, there are two caveats to be mentioned. First of all: if the app crashes hard, then the file will very likely not be deleted, resulting in some inconvenience for the user (he will need to remove the lockfile himself).

Secondly: the java documentation states the following:

createNewFile atomically creates a new, empty file ... if and only if a file with this name does not yet exist. The check for the existence of the file and the creation of the file if it does not exist are a single operation that is atomic with respect to all other filesystem activities that might affect the file. Note: this method should not be used for file-locking, as the resulting protocol cannot be made to work reliably. The FileLock facility should be used instead.

Especially the last note is interesting because in this case we don't really use it for file-locking, merely to check that no other instances of the same application are present. Yet I'm a bit curious to understand why they write that the 'resulting protocol cannot be made to work reliable'

Answer 3

You can use JUnique library. It provides support for running single-instance java application and is open-source. It's based on file locks, but use also random port to send/receive messages from other running java instances.

http://www.sauronsoftware.it/projects/junique/

See also my full answer at How to implement a single instance Java application?

Answer 4

If you are familiar with C, you could address this issue with named pipes in windows and local socket in unix. Both of them require a little of JNI. These communication channel are resources of your application, thus when your application crashes OS has the duty of freeing your resources. Furthermore they are identified by a textual name, so the chance of name clashing is the same for file locking.

You can pickup an example of local socket in this stackoverflow answer.

An example of named pipe in windows could be found here

Answer 5

You may use ManagementFactory object. From here:-

import sun.management.ConnectorAddressLink;  
import sun.jvmstat.monitor.HostIdentifier;  

import sun.jvmstat.monitor.Monitor;  
import sun.jvmstat.monitor.MonitoredHost;  

import sun.jvmstat.monitor.MonitoredVm;  
import sun.jvmstat.monitor.MonitoredVmUtil;  
import sun.jvmstat.monitor.MonitorException;  
import sun.jvmstat.monitor.VmIdentifier;  

public static void main(String args[]) {  
/* The method ManagementFactory.getRuntimeMXBean() returns an identifier with applcation PID
   in the Sun JVM, but each jvm may have you own implementation. 
   So in anothers jvm, other than Sun, this code may not work., :( 
*/  
 RuntimeMXBean rt = ManagementFactory.getRuntimeMXBean();  
         final int runtimePid = Integer.parseInt(rt.getName().substring(0,rt.getName().indexOf("@")));  

  java.awt.EventQueue.invokeLater(new Runnable() {  
  public void run() {  

  // If exists another instance, show message and terminates the current instance.  
  // Otherwise starts application.  
  if (getMonitoredVMs(runtimePid))  
  {  
     new MainFrame().setVisible(true);  
  } else  
  JOptionPane.showMessageDialog(null,"There is another instance of this application running.");  

  }  
  });  
  }

The getMonitoredVMs(int processPid) method receives as paramter the current application PID, and catch the application name that is called from command line, for example, the application was started from c:\java\app\test.jar path, then the value variable is "c:\java\app\teste.jar". This way, we will catch just application name on the line 17 of the code below. After that, we search JVM for antoher process with the same name, if we found it and the application PID is different, it means that is the second application instance.

private static boolean getMonitoredVMs(int processPid) {  
         MonitoredHost host;  
         Set vms;  
try {  
     host = MonitoredHost.getMonitoredHost(new HostIdentifier((String)null));  
     vms = host.activeVms();  
    } catch (java.net.URISyntaxException sx) {  
 throw new InternalError(sx.getMessage());  
  } catch (MonitorException mx) {  
 throw new InternalError(mx.getMessage());  
 }  
 MonitoredVm mvm = null;  
 String processName = null;  
 try{  
     mvm = host.getMonitoredVm(new VmIdentifier(String.valueOf(processPid)));  
     processName = MonitoredVmUtil.commandLine(mvm);  
     processName = processName.substring(processName.lastIndexOf("\\") + 1,processName.length());  
             mvm.detach();  
     } catch (Exception ex) {  

     }  
 // This line is just to verify the process name. It can be removed. 
  JOptionPane.showMessageDialog(null,processName);  
  for (Object vmid: vms) {  
  if (vmid instanceof Integer) {  
  int pid = ((Integer) vmid).intValue();  
  String name = vmid.toString(); // default to pid if name not available  
  try {  
      mvm = host.getMonitoredVm(new VmIdentifier(name));  
      // use the command line as the display name  
    name =  MonitoredVmUtil.commandLine(mvm);  
    name = name.substring(name.lastIndexOf("\\")+1,name.length());  
    mvm.detach();  
    if ((name.equalsIgnoreCase(processName)) && (processPid != pid))  
    return false;  
   } catch (Exception x) {  
   // ignore  
   }  
   }  
   }  

   return true;  
   }

Also check the Using the SingleInstanceService Service

The javax.jnlp.SingleInstanceService provides a set of methods for applications to register themselves as singletons, and to register listener(s) for handling arguments passed in from different instances of applications.