Actualmente estoy creando una aplicación en JAVA donde solo puede haber una ejecución. Así que actualmente estoy usando un archivo de bloqueo en el que escribo el PID de la ejecución actual.
Entonces, cada vez que se inicie esta aplicación, abrirá el archivo (si existe) e intentará detectar si el PID escrito en el archivo se está ejecutando realmente.
Esto evita el problema de que mi aplicación se bloquee antes de desbloquear el archivo.
Necesito que esto funcione tanto en Windows (XP, 7 u 8) como en Linux (todos los usuarios están en distribuciones basadas en Debian).
Aquí hay un código para darle una mejor idea de lo que quiero hacer:
//get the PID from the file int pidValue = new FileReader(file).read(); //get the OS type String os = System.getProperty("os.name").toLowerCase(); //Check PID depending of OS type if( os.contains("nux") || os.contains("nix") ){ /* * Check PID on Linux/Unix */ } else if ( os.contains("win") ) { /* * Check PID on Windows */ }Traté de encontrar documentación sobre el tema, pero aún no logré encontrar nada útil.
Muchísimas gracias.
El código siguiente determina si se está ejecutando un proceso con el pid especificado. Se probó en Windows 7 y Ubuntu 13. En Windows, usa apache commons-exec para ejecutar la lista de tareas y determina si encontraron el pid especificado en función de su código de salida. Supera el hecho de que la lista de tareas siempre devuelve 0 al canalizar el resultado a findstr. En Linux usa ps para hacer lo mismo. También suprime el registro de salida estándar del proceso secundario.
public static boolean isProcessRunning(int pid, int timeout, TimeUnit timeunit) throws java.io.IOException { String line; if (OS.isFamilyWindows()) { //tasklist exit code is always 0. Parse output //findstr exit code 0 if found pid, 1 if it doesn't line = "cmd /c \"tasklist /FI \"PID eq " + pid + "\" | findstr " + pid + "\""; } else { //ps exit code 0 if process exists, 1 if it doesn't line = "ps -p " + pid; //`-p` is POSIX/BSD-compliant, `--pid` isn't<ref>https://github.com/apache/storm/pull/296#discussion_r20535744</ref> } CommandLine cmdLine = CommandLine.parse(line); DefaultExecutor executor = new DefaultExecutor(); // disable logging of stdout/strderr executor.setStreamHandler(new PumpStreamHandler(null, null, null)); // disable exception for valid exit values executor.setExitValues(new int[]{0, 1}); // set timer for zombie process ExecuteWatchdog timeoutWatchdog = new ExecuteWatchdog(timeunit.toMillis(timeout)); executor.setWatchdog(timeoutWatchdog); int exitValue = executor.execute(cmdLine); // 0 is the default exit code which means the process exists return exitValue == 0; }Vea a continuación el ejemplo listo para copiar/pegar.
El método booleano isStillAllive(...) obtendrá como parámetro el número de identificación del proceso (pid). La llamada al método es bastante genérica y está destinada a envolver la lógica dependiente del dispositivo para resolver el mismo problema en sistemas operativos similares a Windows/Linux/Unix.
public boolean isStillAllive(String pidStr) { String OS = System.getProperty("os.name").toLowerCase(); String command = null; if (OS.indexOf("win") >= 0) { log.debug("Check alive Windows mode. Pid: [{}]", pidStr); command = "cmd /c tasklist /FI \"PID eq " + pidStr + "\""; } else if (OS.indexOf("nix") >= 0 || OS.indexOf("nux") >= 0) { log.debug("Check alive Linux/Unix mode. Pid: [{}]", pidStr); command = "ps -p " + pidStr; } else { log.warn("Unsuported OS: Check alive for Pid: [{}] return false", pidStr); return false; } return isProcessIdRunning(pidStr, command); // call generic implementation }La llamada real al sistema se delega a isProcessIdRunning(). Este método invocará el comando dependiente del sistema preformado de manera genérica y el resultado obtenido del sistema se consumirá y analizará línea por línea. Si al menos una de las líneas de respuesta contiene pid, lo interpretamos como un éxito.
private boolean isProcessIdRunning(String pid, String command) { log.debug("Command [{}]",command ); try { Runtime rt = Runtime.getRuntime(); Process pr = rt.exec(command); InputStreamReader isReader = new InputStreamReader(pr.getInputStream()); BufferedReader bReader = new BufferedReader(isReader); String strLine = null; while ((strLine= bReader.readLine()) != null) { if (strLine.contains(" " + pid + " ")) { return true; } } return false; } catch (Exception ex) { log.warn("Got exception using system command [{}].", command, ex); return true; } }En los sistemas posix, la forma típica de consultar si un pid se está ejecutando es enviarle una señal nula, por ejemplo, kill(pid, 0) . Si la llamada tiene éxito, el proceso existe; si devuelve ESRCH no lo hace. Naturalmente, esto está sujeto a condiciones de carrera inevitables que en la realidad son mucho menores que en teoría. Las formas menos uniformes son leer el sistema de archivos /proc (si el sistema operativo tiene uno), que es más trabajo, equivale a lo mismo y aún está sujeto a las mismas condiciones de carrera.
Tenga en cuenta que la técnica del archivo de bloqueo pid puede ser de dos niveles. Es decir, el proceso en ejecución crea el archivo, lo bloquea y escribe su pid. Mantiene el bloqueo durante la duración de su ejecución y, por lo tanto, esto prácticamente elimina la necesidad anterior de consultar si el proceso se está ejecutando porque si el proceso falla, el bloqueo del archivo se liberará automáticamente aunque el archivo aún exista. La lógica es así:
if file exists if can get lock prev instance died unnaturally continue with this new process else instance already running else good to go, continue with new processEsta técnica también tiene condiciones de carrera.
No recuerdo suficiente Java para decir si tiene contenedores para kill o bloquear llamadas al sistema como flock , lockf y fcntl necesarias para implementar este esquema.