Implement a single instance JAVA application

1. Use file lock to ensure single instance is running for this application. 
 private static boolean lockInstance(final String lockFile) {  
   try {  
     final File file = new File(lockFile);  
     final RandomAccessFile randomAccessFile = new RandomAccessFile(file, "rw");  
     final FileLock fileLock = randomAccessFile.getChannel().tryLock();  
     if (fileLock != null) {  
       Runtime.getRuntime().addShutdownHook(new Thread() {  
         public void run() {  
           try {  
             fileLock.release();  
             randomAccessFile.close();  
             file.delete();  
           } catch (Exception e) {  
             log.error("Unable to remove lock file: " + lockFile, e);  
           }  
         }  
       });  
       return true;  
     }  
   } catch (Exception e) {  
     log.error("Unable to create and/or lock file: " + lockFile, e);  
   }  
   return false;  
 }

2. Another file locking example:
2a.JustOneLock.java 
 import java.io.*;  
 import java.nio.channels.*;  
   
 public class JustOneLock {  
   private String appName;  
   private File file;  
   private FileChannel channel;  
   private FileLock lock;  
   
   public JustOneLock(String appName) {  
     this.appName = appName;  
   }  
   
   public boolean isAppActive() {  
     try {  
       file = new File  
          (System.getProperty("user.home"), appName + ".tmp");  
       channel = new RandomAccessFile(file, "rw").getChannel();  
   
       try {  
         lock = channel.tryLock();  
       }  
       catch (OverlappingFileLockException e) {  
         // already locked  
         closeLock();  
         return true;  
       }  
   
       if (lock == null) {  
         closeLock();  
         return true;  
       }  
   
       Runtime.getRuntime().addShutdownHook(new Thread() {  
           // destroy the lock when the JVM is closing  
           public void run() {  
             closeLock();  
             deleteFile();  
           }  
         });  
       return false;  
     }  
     catch (Exception e) {  
       closeLock();  
       return true;  
     }  
   }  
   
   private void closeLock() {  
     try { lock.release(); }  
     catch (Exception e) { }  
     try { channel.close(); }  
     catch (Exception e) { }  
   }  
   
   private void deleteFile() {  
     try { file.delete(); }  
     catch (Exception e) { }  
   }  
 }

2b. JustOneTest.java 
 public class JustOneTest {  
   public static void main(String[] args) {  
     new JustOneTest().test();  
   }  
   
   void test() {  
     JustOneLock ua = new JustOneLock("JustOneId");  
   
     if (ua.isAppActive()) {  
       System.out.println("Already active.");  
       System.exit(1);    
     }  
     else {  
       System.out.println("NOT already active.");  
       try {  
         while(true) {  
            try { System.out.print("."); Thread.sleep(5 * 60); }  
            catch(Exception e) { e.printStackTrace(); }  
         }  
        }  
       catch (Exception e) { }  
     }  
   }  
 }

3. Improved File locking to solve: People can still run another copy of application from another folder where your program was copied.
3a. Application use AppLock class 
 try {  
   // Try to get LOCK //  
   if (!AppLock.setLock("MY_CUSTOM_LOCK_KEY")) {  
     throw new RuntimeException("Only one application instance may run at the same time!");  
   }  
   
   // YOUR CODE  
 }  
 finally{  
   AppLock.releaseLock(); // Release lock  
 }

3b. AppLock class 
 import java.io.File;  
 import java.io.FileOutputStream;  
 import java.nio.channels.FileChannel;  
 import java.nio.channels.FileLock;  
 import java.util.logging.Level;  
 import java.util.logging.Logger;  
   
 /**  
  * AppLock  
  * @author http://fresh2L.com  
  * @version 1.0  
  */  
 public class AppLock  
 {  
   
  /** hidden constructor */  
  private AppLock() { }  
   
  /** Lock file */  
  File lock_file = null;  
   
  FileLock lock = null;  
   
  FileChannel lock_channel = null;  
   
  FileOutputStream lock_stream = null;  
   
  /**  
   * Creates class lock instance  
   * @param key Unique application key  
   */  
  private AppLock(String key) throws Exception  
  {  
   String tmp_dir = System.getProperty("java.io.tmpdir");  
   if (!tmp_dir.endsWith(System.getProperty("file.separator"))) {  
    tmp_dir += System.getProperty("file.separator");  
   }  
     
   // Acquire MD5  
   try {  
    java.security.MessageDigest md = java.security.MessageDigest.getInstance("MD5");  
    md.reset();  
    String hash_text = new java.math.BigInteger(1, md.digest(key.getBytes())).toString(16);  
   
    while (hash_text.length() < 32) {  
     hash_text = "0" + hash_text;  
    }  
    lock_file = new File(tmp_dir + hash_text + ".app_lock");  
   }  
   catch (Exception ex) {  
   }  
   
   // MD5 acquire fail  
   if (lock_file == null) {  
     lock_file = new File(tmp_dir + key + ".app_lock");  
   }  
   
   lock_stream = new FileOutputStream(lock_file);  
   
   String f_content = "Java AppLock Object\r\nLocked by key: " + key + "\r\n";  
   lock_stream.write(f_content.getBytes());  
   
   lock_channel = lock_stream.getChannel();  
   
   lock = lock_channel.tryLock();  
   
   if (lock == null) {  
    throw new Exception("Can't create Lock");  
   }  
  }  
   
  /**  
   * Remove Lock. Now another application instance can gain lock.  
   * @throws Throwable  
   */  
  private void release() throws Throwable  
  {  
   if (lock != null) {  
    lock.release();  
   }  
   
   if (lock_channel != null) {  
    lock_channel.close();  
   }  
   
   if (lock_stream != null) {  
    lock_stream.close();  
   }  
   
   if (lock_file != null) {  
    lock_file.delete();  
   }  
  }  
   
  @Override  
  protected void finalize() throws Throwable  
  {  
   this.release();  
   super.finalize();  
  }  
   
  private static AppLock instance;  
   
  /**  
   * Set Lock based on input key  
   * Method can be run only one time per application. Second calls will be ignored.  
   *  
   * @param key Lock key  
   */  
  public static boolean setLock(String key)  
  {  
   if (instance != null) {  
    return true;  
   }  
   
   try {  
    instance = new AppLock(key);  
   }  
   catch (Exception ex) {  
    instance = null;  
    Logger.getLogger(Application.class.getName()).log(Level.SEVERE, "Обламался AppLock", ex);  
    return false;  
   }  
   
   Runtime.getRuntime().addShutdownHook(new Thread()  
   {  
    @Override  
    public void run()  
    {  
     AppLock.releaseLock();  
    }  
   });  
   return true;  
  }  
   
  /**  
   * Try to release Lock.  
   * After releasing you can not user AppLock again in application.  
   */  
  public static void releaseLock()  
  {  
   if (instance == null) {  
    return;  
   }  
   try {  
    instance.release();  
   }  
   catch (Throwable ex) {  
    Logger.getLogger(AppLock.class.getName()).log(Level.SEVERE, null, ex);  
   }  
  }  
 }

4. Socket technique
4a. Server 
 import java.io.*;  
 import java.net.*;  
   
 public class JustOneServer extends Thread {  
   // you may need to customize this for your machine  
   public static final int PORT = 80 ;   
   
   ServerSocket serverSocket = null;  
   Socket clientSocket = null;  
   
   public void run() {  
   try {  
    // Create the server socket  
    serverSocket = new ServerSocket(port, 1);  
    while (true) {  
     // Wait for a connection  
     clientSocket = serverSocket.accept();  
     // System.out.println("*** Got a connection! ");  
     clientSocket.close();  
     }  
    }  
   catch (IOException ioe) {  
    System.out.println("Error in JustOneServer: " + ioe);  
    }  
   }  
  }

4b. Client 
 import java.io.*;  
 import java.net.*;  
   
 public class JustOne {  
  SimpleDummyServer sds = null;   
   
  public static void main(String args[]){  
   new JustOne().doit();  
   }  
   
  public void doit() {  
   try {  
    Socket clientSocket = new Socket("localhost", JustOneServer.PORT);  
    System.out.println("*** Already running!");  
    System.exit(1);  
    }  
   catch (Exception e) {  
    sds = new JustOneServer();  
    sds.start();  
    }  
     
   while(true) {  
    try { System.out.print("."); Thread.sleep(5 * 60); }  
    catch(Exception e) { e.printStackTrace(); }  
    }  
   }  
  }

5. Another socket approach
5a. ApplicationInstanceManager class
 public class ApplicationInstanceManager {  
   
   private static ApplicationInstanceListener subListener;  
   
   /** Randomly chosen, but static, high socket number */  
   public static final int SINGLE_INSTANCE_NETWORK_SOCKET = 44331;  
   
   /** Must end with newline */  
   public static final String SINGLE_INSTANCE_SHARED_KEY = "$$NewInstance$$\n";  
   
   /**  
    * Registers this instance of the application.  
    *  
    * @return true if first instance, false if not.  
    */  
   public static boolean registerInstance() {  
     // returnValueOnError should be true if lenient (allows app to run on network error) or false if strict.  
     boolean returnValueOnError = true;  
     // try to open network socket  
     // if success, listen to socket for new instance message, return true  
     // if unable to open, connect to existing and send new instance message, return false  
     try {  
       final ServerSocket socket = new ServerSocket(SINGLE_INSTANCE_NETWORK_SOCKET, 10, InetAddress  
           .getLocalHost());  
       log.debug("Listening for application instances on socket " + SINGLE_INSTANCE_NETWORK_SOCKET);  
       Thread instanceListenerThread = new Thread(new Runnable() {  
         public void run() {  
           boolean socketClosed = false;  
           while (!socketClosed) {  
             if (socket.isClosed()) {  
               socketClosed = true;  
             } else {  
               try {  
                 Socket client = socket.accept();  
                 BufferedReader in = new BufferedReader(new InputStreamReader(client.getInputStream()));  
                 String message = in.readLine();  
                 if (SINGLE_INSTANCE_SHARED_KEY.trim().equals(message.trim())) {  
                   log.debug("Shared key matched - new application instance found");  
                   fireNewInstance();  
                 }  
                 in.close();  
                 client.close();  
               } catch (IOException e) {  
                 socketClosed = true;  
               }  
             }  
           }  
         }  
       });  
       instanceListenerThread.start();  
       // listen  
     } catch (UnknownHostException e) {  
       log.error(e.getMessage(), e);  
       return returnValueOnError;  
     } catch (IOException e) {  
       log.debug("Port is already taken. Notifying first instance.");  
       try {  
         Socket clientSocket = new Socket(InetAddress.getLocalHost(), SINGLE_INSTANCE_NETWORK_SOCKET);  
         OutputStream out = clientSocket.getOutputStream();  
         out.write(SINGLE_INSTANCE_SHARED_KEY.getBytes());  
         out.close();  
         clientSocket.close();  
         log.debug("Successfully notified first instance.");  
         return false;  
       } catch (UnknownHostException e1) {  
         log.error(e.getMessage(), e);  
         return returnValueOnError;  
       } catch (IOException e1) {  
         log.error("Error connecting to local port for single instance notification");  
         log.error(e1.getMessage(), e1);  
         return returnValueOnError;  
       }  
   
     }  
     return true;  
   }  
   
   public static void setApplicationInstanceListener(ApplicationInstanceListener listener) {  
     subListener = listener;  
   }  
   
   private static void fireNewInstance() {  
    if (subListener != null) {  
     subListener.newInstanceCreated();  
    }  
  }  
 }

5b. Listener Interface 
 public interface ApplicationInstanceListener {  
   public void newInstanceCreated();  
 }

5c. Main application 
 public class MyApplication {  
   public static void main(String[] args) {  
     if (!ApplicationInstanceManager.registerInstance()) {  
           // instance already running.  
           System.out.println("Another instance of this application is already running. Exiting.");  
           System.exit(0);  
     }  
     ApplicationInstanceManager.setApplicationInstanceListener(new ApplicationInstanceListener() {  
      public void newInstanceCreated() {  
        System.out.println("New instance detected...");  
        // this is where your handler code goes...  
      }  
     });  
   }  
 }

6. Use Launch4j to wrap the application
http://launch4j.sourceforge.net/

7. Use sun.jvmstat package
http://java.sun.com/performance/jvmstat/
7a. Main class 
 // imports  
 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.");  
  }  
  });  
  })

7b. Method getMoniteredVMs
 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;  
      }

Reference:
http://www.rgagnon.com/javadetails/java-0288.html
http://audiprimadhanty.wordpress.com/2008/06/30/ensuring-one-instance-of-application-running-at-one-time/ 
http://www.rbgrn.net/content/43-java-single-application-instance

留言

張貼留言

這個網誌中的熱門文章

java.lang.NoClassDefFoundError: org/apache/xerces/jaxp/datatype/XMLGregorianCalendarImpl$Parser

When you encounter the following error that related to web service. java.lang.NoClassDefFoundError: org/apache/xerces/jaxp/datatype/XMLGregorianCalendarImpl$Parser Solution 1: Ensure no xercesImpl.jar in your classpath since the implementation of xerce is built-in wiht JAVA SE 1.6. Solution 2: Use XmlJavaTypeAdapter [ @XmlJavaTypeAdapter(JaxbDateAdapter.class)] to convert XMLGregorianCalendar type to Date type. XMLGregorianCalendar is the built-in Java data type for JAXB mapping with datetime. Example: Binding.xjb <?xml version="1.0" encoding="UTF-8"?> <bindings xmlns="http://java.sun.com/xml/ns/jaxb"                 xmlns:xsi="http://www.w3.org/2000/10/XMLSchema-instance"                 xmlns:xjc="http://java.sun.com/xml/ns/jaxb/xjc"               ...
閱讀完整內容

10 Tips for Proper Application Logging

圖片
Reference: https://www.javacodegeeks.com/2011/01/10-tips-proper-application-logging.html   Our latest   JCP partner ,   Tomasz Nurkiewicz , has submitted a number of posts describing the basic principles of proper application   logging . I found them quite interesting, thus I decided to aggregate them in a more compact format and present them to you. So, here are his suggestions for clean and helpful logs:(NOTE: The original posts have been slightly edited to improve readability) 1) Use the appropriate tools for the job Many programmers seem to forget how important is logging an application’s behavior and its current activity. When somebody puts: 1 log.info( "Happy and carefree logging" ); happily somewhere in the code, he probably doesn’t realize the importance of application logs during maintenance, tuning and failure identification. Underestimating the value of good logs is a terrible mistake. In my opinion, SLF4J is the best logging API availab...
閱讀完整內容

Turn off WebLogic basic authentication

Editing config.xml To set the e enforce-valid-basic-auth-credentials flag, perform the following steps: 1. Add the element to config.xml within the element. false 2. Start or restart all of the servers in the domain. ============================================= Using WebLogic Scripting Tool (WLST) Using WLST to Check the Value of enforce-valid-basic-auth-credentials The Administration Console does not display or log the enforce-valid-basic-auth-credentials setting. However, you can use WLST to check the value in a running server. Remember that enforce-valid-basic-auth-credentials is a domain-wide setting. The WLST session shown below demonstrates how to check the value of the enforce-valid-basic-auth-credentials flag in a sample running server. Example: wls:/offline> connect('weblogic','weblogic123','t3://localhost:7002') Connecting to t3://localhost:7002 with userid weblogic ... Successfully connected to Admin Server 'AdminS...
閱讀完整內容