Comment autoriser l'exécution d'une seule instance d'un programme Java à un moment?

Je pense que votre suggestion de l'ouverture d'un port à écouter lorsque vous démarrez votre application est la meilleure idée.

Il est très facile à faire et vous n'avez pas besoin de vous soucier du nettoyage lorsque vous fermez votre application. Par exemple, si vous écrivez à un fichier, mais quelqu'un tue alors le processus à l'aide de Gestionnaire de Tâches le fichier ne sera pas supprimé.

Aussi, si je me souviens bien il n'y a pas de moyen facile d'obtenir le PID d'un processus Java à partir de l'intérieur de la JVM donc, ne pas essayer et de trouver une solution à l'aide de PIDs.

Quelque chose comme cela devrait faire l'affaire:

private static final int PORT = 9999;
private static ServerSocket socket;    

private static void checkIfRunning() {
  try {
    //Bind to localhost adapter with a zero connection queue 
    socket = new ServerSocket(PORT,0,InetAddress.getByAddress(new byte[] {127,0,0,1}));
  }
  catch (BindException e) {
    System.err.println("Already running.");
    System.exit(1);
  }
  catch (IOException e) {
    System.err.println("Unexpected error.");
    e.printStackTrace();
    System.exit(2);
  }
}

Cet exemple de code explicitement se lie à 127.0.0.1 qui devrait éviter tout pare-feu mises en garde, que tout le trafic sur cette adresse doit être à partir du système local.

Lors de la sélection d'un port d'essayer d'éviter que celle mentionnée dans la liste des Bien Connu Ports. Vous devriez idéalement rendre le port utilisé configurable dans un fichier ou par l'intermédiaire d'un commutateur de ligne de commande dans le cas de conflits.

Je pense que la meilleure idée serait d'utiliser le verrouillage de fichier (tout à fait une vieille idée 🙂 ). Depuis Java 1.4 une nouvelle bibliothèque d'e/S a été introduit, qui permet le verrouillage de fichier.

Une fois que l'application démarre, il essaie d'acquérir le verrou sur un fichier (ou le créer si il n'existe pas), lorsque l'application se ferme le verrou est publiée. Si l'application ne peut pas acquérir un verrou, il se ferme.

L'exemple, comment le faire de verrouillage de fichier est par exemple dans Développeurs Java Almanach.

Si vous souhaitez utiliser le verrouillage de fichier dans l'application Java Web Start ou une applet, vous devez chanter l'application ou de l'applet.

Vous pouvez utiliser JUnique de la bibliothèque. Il fournit un support pour l'exécution d'une seule instance de l'application java et est open-source.

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

Voir aussi ma réponse à Comment mettre en œuvre une seule instance de l'application Java?

Vous pouvez utiliser le registre, bien que cette moitié de défaites le but de l'utilisation d'un langage de haut niveau comme java. Au moins votre plate-forme cible est windows =D

J'ai vu beaucoup de ces questions, et je cherchais à résoudre le même problème dans une plate-forme indépendante de façon à ne pas prendre le risque d'entrer en collision avec le pare-feu ou obtenir sur la prise de trucs.

Donc, voici ce que j'ai fait:

import java.io.File;
import java.io.IOException;

/**
 * This static class is in charge of file-locking the program
 * so no more than one instance can be run at the same time.
 * @author nirei
 */
public class SingleInstanceLock {

    private static final String LOCK_FILEPATH = System.getProperty("java.io.tmpdir") + File.separator + "lector.lock";
    private static final File lock = new File(LOCK_FILEPATH);
    private static boolean locked = false;

    private SingleInstanceLock() {}

    /**
     * Creates the lock file if it's not present and requests its deletion on
     * program termination or informs that the program is already running if
     * that's the case.
     * @return true - if the operation was succesful or if the program already has the lock.<br>
     * false - if the program is already running
     * @throws IOException if the lock file cannot be created.
     */
    public static boolean lock() throws IOException {
        if(locked) return true;

        if(lock.exists()) return false;

        lock.createNewFile();
        lock.deleteOnExit();
        locked = true;
        return true;
    }
}

En Utilisant Le Système.getProperty("java.io.tmpdir") pour le chemin du fichier de verrouillage permet de s'assurer que vous aurez toujours créer votre serrure sur la même place.

Puis, à partir de votre programme, vous appelez simplement quelque chose comme:

blah blah main(blah blah blah) {
    try() {
        if(!SingleInstanceLock.lock()) {
            System.out.println("The program is already running");
            System.exit(0);
        }
    } catch (IOException e) {
        System.err.println("Couldn't create lock file or w/e");
        System.exit(1);
    }
}

Et qui le fait pour moi. Maintenant, si vous tuez le programme, il ne sera pas effacer le fichier de verrouillage, mais vous pouvez résoudre ce problème en écrivant le programme du PID dans le fichier de verrouillage et de faire la méthode lock() vérifier si ce processus est déjà en cours d'exécution. Il reste comme un assingment pour toute personne intéressée. 🙂