Comment implémenter une application Java à instance unique?

Parfois, je vois de nombreuses applications telles que msn, Windows Media Player, etc. qui sont des applications à instance unique (lorsque l'utilisateur s'exécute pendant que l'application exécute une nouvelle instance d'application ne sera pas créée).

En C #, j'utilise la Mutexclasse pour cela mais je ne sais pas comment faire cela en Java.

Si je crois cet article , par:

avoir la première tentative d'ouvrir une socket d'écoute sur l'interface localhost. S'il est capable d'ouvrir le socket, on suppose qu'il s'agit de la première instance de l'application à être lancée. Sinon, l'hypothèse est qu'une instance de cette application est déjà en cours d'exécution. La nouvelle instance doit informer l'instance existante qu'une tentative de lancement a été effectuée, puis quitter. L'instance existante prend le relais après avoir reçu la notification et déclenche un événement vers l'écouteur qui gère l'action.

Remarque: Ahe mentionne dans le commentaire que l'utilisation InetAddress.getLocalHost()peut être délicate:

• cela ne fonctionne pas comme prévu dans l'environnement DHCP car l'adresse renvoyée dépend du fait que l'ordinateur dispose ou non d'un accès réseau.
  La solution était d'ouvrir la connexion avec InetAddress.getByAddress(new byte[] {127, 0, 0, 1});
  Probablement lié au bogue 4435662 .

• J'ai également trouvé le bogue 4665037 qui rapporte que Résultats attendus de getLocalHost: retour de l'adresse IP de la machine, vs résultats réels: retour 127.0.0.1.

il est surprenant d'avoir un getLocalHostretour 127.0.0.1sur Linux mais pas sur windows.

Ou vous pouvez utiliser un ManagementFactoryobjet. Comme expliqué ici :

La getMonitoredVMs(int processPid)méthode reçoit comme paramètre le PID de l'application en cours et récupère le nom de l'application qui est appelé à partir de la ligne de commande, par exemple, l'application a été démarrée à partir du c:\java\app\test.jarchemin, la variable de valeur est " c:\\java\\app\\test.jar". De cette façon, nous attraperons juste le nom de l'application sur la ligne 17 du code ci-dessous.
Après cela, nous recherchons dans JVM un autre processus avec le même nom, si nous l'avons trouvé et que le PID de l'application est différent, cela signifie qu'il s'agit de la deuxième instance d'application.

JNLP offre également un SingleInstanceListener

J'utilise la méthode suivante dans la méthode principale. C'est la méthode la plus simple, la plus robuste et la moins intrusive que j'ai vue, alors j'ai pensé que je la partagerais.

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;
}

Si l'application. a une interface graphique, lancez-la avec JWS et utilisez le SingleInstanceService.

Mettre à jour

Le plug-in Java (requis pour les applets et les applications JWS) a été abandonné par Oracle et supprimé du JDK. Les fabricants de navigateurs l'avaient déjà supprimé de leurs navigateurs.

Cette réponse est donc caduque. Ne le laissant ici que pour avertir les personnes qui consultent de la documentation ancienne.

Oui, c'est une réponse vraiment décente pour l'application d'instance unique eclipse RCP eclipse ci-dessous est mon code

dans application.java

if(!isFileshipAlreadyRunning()){
        MessageDialog.openError(display.getActiveShell(), "Fileship already running", "Another instance of this application is already running.  Exiting.");
        return IApplication.EXIT_OK;
    } 


private static boolean isFileshipAlreadyRunning() {
    // socket concept is shown at http://www.rbgrn.net/content/43-java-single-application-instance
    // but this one is really great
    try {
        final File file = new File("FileshipReserved.txt");
        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;
}

Nous utilisons le verrouillage de fichier pour cela (saisir un verrou exclusif sur un fichier magique dans le répertoire de données de l'application de l'utilisateur), mais nous sommes principalement intéressés à empêcher plusieurs instances de s'exécuter.

Si vous essayez de faire passer la deuxième instance des arguments de ligne de commande, etc ... à la première instance, alors utiliser une connexion socket sur localhost tuera deux oiseaux avec une pierre. Algorithme général:

• Au lancement, essayez d'ouvrir l'écouteur sur le port XXXX sur localhost
• en cas d'échec, ouvrez un graveur sur ce port sur l'hôte local et envoyez les arguments de ligne de commande, puis arrêtez
• sinon, écoutez sur le port XXXXX sur localhost. Lorsque vous recevez des arguments de ligne de commande, traitez-les comme si l'application avait été lancée avec cette ligne de commande.

J'ai trouvé une solution, une explication un peu caricaturale, mais qui fonctionne toujours dans la plupart des cas. Il utilise l'ancien fichier de verrouillage pour créer des trucs, mais dans une vue assez différente:

http://javalandscape.blogspot.com/2008/07/single-instance-from-your-application.html

Je pense que ce sera une aide pour ceux qui ont un paramètre de pare-feu strict.

Vous pouvez utiliser la bibliothèque JUnique. Il prend en charge l'exécution d'une application Java à instance unique et est open source.

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

La bibliothèque JUnique peut être utilisée pour empêcher un utilisateur d'exécuter en même temps plusieurs instances de la même application Java.

JUnique implémente des verrous et des canaux de communication partagés entre toutes les instances JVM lancées par le même utilisateur.

public static void main(String[] args) {
    String appId = "myapplicationid";
    boolean alreadyRunning;
    try {
        JUnique.acquireLock(appId, new MessageHandler() {
            public String handle(String message) {
                // A brand new argument received! Handle it!
                return null;
            }
        });
        alreadyRunning = false;
    } catch (AlreadyLockedException e) {
        alreadyRunning = true;
    }
    if (!alreadyRunning) {
        // Start sequence here
    } else {
        for (int i = 0; i < args.length; i++) {
            JUnique.sendMessage(appId, args[0]));
        }
    }
}

Sous le capot, il crée des verrous de fichiers dans le dossier% USER_DATA% /. Junique et crée un socket serveur sur un port aléatoire pour chaque appId unique qui permet d'envoyer / recevoir des messages entre les applications java.

Sous Windows, vous pouvez utiliser launch4j .

Classe ManagementFactory prise en charge dans le détail J2SE 5.0 ou version ultérieure

mais maintenant j'utilise J2SE 1.4 et j'ai trouvé celui-ci http://audiprimadhanty.wordpress.com/2008/06/30/ensuring-one-instance-of-application-running-at-one-time/ mais je n'ai jamais testé. Qu'est-ce que tu en penses?

Vous pouvez essayer d'utiliser l'API Preferences. Il est indépendant de la plateforme.

Une manière plus générique de limiter le nombre d'instances sur une seule machine, voire sur un réseau entier, consiste à utiliser un socket multicast.

L'utilisation d'un socket de multidiffusion vous permet de diffuser un message vers n'importe quel nombre d'instances de votre application, dont certaines peuvent se trouver sur des machines physiquement distantes sur un réseau d'entreprise.

De cette façon, vous pouvez activer de nombreux types de configurations, pour contrôler des éléments tels que

• Une ou plusieurs instances par machine
• Une ou plusieurs instances par réseau (par exemple, contrôle des installations sur un site client)

Le support multicast de Java se fait via le package java.net avec MulticastSocket et DatagramSocket étant les principaux outils.

Remarque : MulticastSocket ne garantit pas la livraison des paquets de données, vous devez donc utiliser un outil construit sur des sockets multicast comme JGroups . JGroups fait la livraison de garantie de toutes les données. Il s'agit d'un seul fichier jar, avec une API très simple.

JGroups existe depuis un certain temps et a des utilisations impressionnantes dans l'industrie, par exemple, il sous-tend le mécanisme de clustering de JBoss pour diffuser des données à toutes les instances d'un cluster.

Utiliser JGroups, limiter le nombre d'instances d'une application (sur une machine ou un réseau, disons: au nombre de licences qu'un client a achetées) est conceptuellement très simple:

• Au démarrage de votre application, chaque instance essaie de rejoindre un groupe nommé, par exemple "My Great App Group". Vous aurez configuré ce groupe pour autoriser 0, 1 ou N membres
• Lorsque le nombre de membres du groupe est supérieur à ce que vous avez configuré pour cela, votre application doit refuser de démarrer.

Vous pouvez ouvrir un fichier mappé en mémoire et voir si ce fichier est déjà OUVERT. s'il est déjà ouvert, vous pouvez revenir de main.

Une autre façon est d'utiliser des fichiers de verrouillage (pratique standard Unix). Une autre façon est de mettre quelque chose dans le presse-papiers au démarrage de main après avoir vérifié si quelque chose se trouve déjà dans le presse-papiers.

Sinon, vous pouvez ouvrir une socket en mode écoute (ServerSocket). Essayez d'abord de vous connecter à la prise hte; si vous ne pouvez pas vous connecter, ouvrez un serveur de socket. si vous vous connectez, vous savez qu'une autre instance est déjà en cours d'exécution.

Ainsi, à peu près n'importe quelle ressource système peut être utilisée pour savoir qu'une application est en cours d'exécution.

BR, ~ A

J'ai utilisé des sockets pour cela et selon si l'application est côté client ou côté serveur, le comportement est un peu différent:

• côté client: si une instance existe déjà (je ne peux pas écouter sur un port spécifique) je passerai les paramètres de l'application et quitterai (vous voudrez peut-être effectuer certaines actions dans l'instance précédente) sinon je vais démarrer l'application.
• côté serveur: si une instance existe déjà, j'imprimerai un message et quitterai, sinon je lancerai l'application.

classe publique SingleInstance {
    public static final String LOCK = System.getProperty ("user.home") + File.separator + "test.lock";
    public static final String PIPE = System.getProperty ("user.home") + File.separator + "test.pipe";
    Trame JFrame statique privée = null;

    public static void main (String [] args) {
        essayez {
            FileChannel lockChannel = nouveau RandomAccessFile (LOCK, "rw"). GetChannel ();
            FileLock flk = null; 
            essayez {
                flk = lockChannel.tryLock ();
            } catch (Throwable t) {
                t.printStackTrace ();
            }
            if (flk == null ||! flk.isValid ()) {
                System.out.println ("déjà en cours d'exécution, laisser un message à diriger et quitter ...");
                FileChannel pipeChannel = null;
                essayez {
                    pipeChannel = new RandomAccessFile (PIPE, "rw"). getChannel ();
                    MappedByteBuffer bb = pipeChannel.map (FileChannel.MapMode.READ_WRITE, 0, 1);
                    bb.put (0, (octet) 1);
                    bb.force ();
                } catch (Throwable t) {
                    t.printStackTrace ();
                } enfin {
                    if (pipeChannel! = null) {
                        essayez {
                            pipeChannel.close ();
                        } catch (Throwable t) {
                            t.printStackTrace ();
                        }
                    } 
                }
                System.exit (0);
            }
            // Nous ne libérons pas le verrou et fermons le canal ici, 
            // qui sera fait après que l'application plante ou se ferme normalement. 
            SwingUtilities.invokeLater (
                nouveau Runnable () {
                    public void run () {
                        createAndShowGUI ();
                    }
                }
            );

            FileChannel pipeChannel = null;
            essayez {
                pipeChannel = new RandomAccessFile (PIPE, "rw"). getChannel ();
                MappedByteBuffer bb = pipeChannel.map (FileChannel.MapMode.READ_WRITE, 0, 1);
                while (vrai) {
                    octet b = bb.get (0);
                    si (b> 0) {
                        bb.put (0, (octet) 0);
                        bb.force ();
                        SwingUtilities.invokeLater (
                            nouveau Runnable () {
                                public void run () {
                                    frame.setExtendedState (JFrame.NORMAL);
                                    frame.setAlwaysOnTop (true);
                                    frame.toFront ();
                                    frame.setAlwaysOnTop (false);
                                }
                            }
                        );
                    }
                    Thread.sleep (1000);
                }
            } catch (Throwable t) {
                t.printStackTrace ();
            } enfin {
                if (pipeChannel! = null) {
                    essayez {
                        pipeChannel.close ();
                    } catch (Throwable t) {
                        t.printStackTrace ();
                    } 
                } 
            }
        } catch (Throwable t) {
            t.printStackTrace ();
        } 
    }

    public static void createAndShowGUI () {

        frame = new JFrame ();
        frame.setDefaultCloseOperation (JFrame.EXIT_ON_CLOSE);
        frame.setSize (800, 650);
        frame.getContentPane (). add (new JLabel ("MAIN WINDOW", 
                    SwingConstants.CENTER), BorderLayout.CENTER);
        frame.setLocationRelativeTo (null);
        frame.setVisible (vrai);
    }
}

EDIT : Au lieu d'utiliser cette approche WatchService, un simple thread de minuterie de 1 seconde pourrait être utilisé pour vérifier si le paramètre IndicatorFile.exists (). Supprimez-le, puis placez l'application au premier plan ().

EDIT : Je voudrais savoir pourquoi cela a été déclassé. C'est la meilleure solution que j'ai vue jusqu'à présent. Par exemple, l'approche de socket serveur échoue si une autre application écoute déjà le port.

Téléchargez simplement Microsoft Windows Sysinternals TCPView (ou utilisez netstat), démarrez-le, triez par "État", recherchez le bloc de ligne qui dit "ÉCOUTE", choisissez celui dont l'adresse distante indique le nom de votre ordinateur, mettez ce port dans votre nouveau Socket ()-Solution. Dans ma mise en œuvre, je peux produire un échec à chaque fois. Et c'est logique , car c'est le fondement même de la démarche. Ou qu'est-ce que je ne reçois pas sur la façon de mettre en œuvre cela?

Veuillez m'informer si et comment je me trompe à ce sujet!

Mon opinion - que je vous demande de réfuter si possible - est que les développeurs sont invités à utiliser une approche dans le code de production qui échouera dans au moins 1 cas sur environ 60000. Et si ce point de vue s'avère correct, alors il est impossible qu'une solution présentée qui ne présente pas ce problème soit rejetée et critiquée pour sa quantité de code.

Inconvénients de l'approche socket en comparaison:

• Échoue si le mauvais ticket de loterie (numéro de port) est choisi.
• Échec dans un environnement multi-utilisateur: un seul utilisateur peut exécuter l'application à la fois. (Mon approche devrait être légèrement modifiée pour créer le (s) fichier (s) dans l'arborescence des utilisateurs, mais c'est trivial.)
• Échoue si les règles de pare-feu sont trop strictes.
• Les utilisateurs suspects (que j'ai rencontrés dans la nature) se demandent quelles manigances vous faites lorsque votre éditeur de texte revendique une socket serveur.

J'ai juste eu une bonne idée sur la façon de résoudre le problème de communication Java nouvelle-instance-instance-existante d'une manière qui devrait fonctionner sur tous les systèmes. Alors, j'ai organisé ce cours en environ deux heures. Fonctionne comme un charme: D

Il est basé sur l' approche de verrouillage de fichier de Robert (également sur cette page), que j'ai utilisée depuis. Pour indiquer à l'instance déjà en cours d'exécution qu'une autre instance a essayé de démarrer (mais ne l'a pas fait) ... un fichier est créé et immédiatement supprimé, et la première instance utilise WatchService pour détecter ce changement de contenu de dossier. Je n'arrive pas à croire qu'il s'agisse apparemment d'une nouvelle idée, étant donné la gravité du problème.

Cela peut facilement être changé pour simplement créer et non supprimer le fichier, puis des informations peuvent y être placées que l'instance appropriée peut évaluer, par exemple les arguments de la ligne de commande - et l'instance appropriée peut alors effectuer la suppression. Personnellement, je n'avais besoin que de savoir quand restaurer la fenêtre de mon application et l'envoyer au premier plan.

Exemple d'utilisation:

public static void main(final String[] args) {

    // ENSURE SINGLE INSTANCE
    if (!SingleInstanceChecker.INSTANCE.isOnlyInstance(Main::otherInstanceTriedToLaunch, false)) {
        System.exit(0);
    }

    // launch rest of application here
    System.out.println("Application starts properly because it's the only instance.");
}

private static void otherInstanceTriedToLaunch() {
    // Restore your application window and bring it to front.
    // But make sure your situation is apt: This method could be called at *any* time.
    System.err.println("Deiconified because other instance tried to start.");
}

Voici la classe:

package yourpackagehere;

import javax.swing.*;
import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.channels.FileLock;
import java.nio.file.*;




/**
 * SingleInstanceChecker v[(2), 2016-04-22 08:00 UTC] by dreamspace-president.com
 * <p>
 * (file lock single instance solution by Robert https://stackoverflow.com/a/2002948/3500521)
 */
public enum SingleInstanceChecker {

    INSTANCE; // HAHA! The CONFUSION!


    final public static int POLLINTERVAL = 1000;
    final public static File LOCKFILE = new File("SINGLE_INSTANCE_LOCKFILE");
    final public static File DETECTFILE = new File("EXTRA_INSTANCE_DETECTFILE");


    private boolean hasBeenUsedAlready = false;


    private WatchService watchService = null;
    private RandomAccessFile randomAccessFileForLock = null;
    private FileLock fileLock = null;


    /**
     * CAN ONLY BE CALLED ONCE.
     * <p>
     * Assumes that the program will close if FALSE is returned: The other-instance-tries-to-launch listener is not
     * installed in that case.
     * <p>
     * Checks if another instance is already running (temp file lock / shutdownhook). Depending on the accessibility of
     * the temp file the return value will be true or false. This approach even works even if the virtual machine
     * process gets killed. On the next run, the program can even detect if it has shut down irregularly, because then
     * the file will still exist. (Thanks to Robert https://stackoverflow.com/a/2002948/3500521 for that solution!)
     * <p>
     * Additionally, the method checks if another instance tries to start. In a crappy way, because as awesome as Java
     * is, it lacks some fundamental features. Don't worry, it has only been 25 years, it'll sure come eventually.
     *
     * @param codeToRunIfOtherInstanceTriesToStart Can be null. If not null and another instance tries to start (which
     *                                             changes the detect-file), the code will be executed. Could be used to
     *                                             bring the current (=old=only) instance to front. If null, then the
     *                                             watcher will not be installed at all, nor will the trigger file be
     *                                             created. (Null means that you just don't want to make use of this
     *                                             half of the class' purpose, but then you would be better advised to
     *                                             just use the 24 line method by Robert.)
     *                                             <p>
     *                                             BE CAREFUL with the code: It will potentially be called until the
     *                                             very last moment of the program's existence, so if you e.g. have a
     *                                             shutdown procedure or a window that would be brought to front, check
     *                                             if the procedure has not been triggered yet or if the window still
     *                                             exists / hasn't been disposed of yet. Or edit this class to be more
     *                                             comfortable. This would e.g. allow you to remove some crappy
     *                                             comments. Attribution would be nice, though.
     * @param executeOnAWTEventDispatchThread      Convenience function. If false, the code will just be executed. If
     *                                             true, it will be detected if we're currently on that thread. If so,
     *                                             the code will just be executed. If not so, the code will be run via
     *                                             SwingUtilities.invokeLater().
     * @return if this is the only instance
     */
    public boolean isOnlyInstance(final Runnable codeToRunIfOtherInstanceTriesToStart, final boolean executeOnAWTEventDispatchThread) {

        if (hasBeenUsedAlready) {
            throw new IllegalStateException("This class/method can only be used once, which kinda makes sense if you think about it.");
        }
        hasBeenUsedAlready = true;

        final boolean ret = canLockFileBeCreatedAndLocked();

        if (codeToRunIfOtherInstanceTriesToStart != null) {
            if (ret) {
                // Only if this is the only instance, it makes sense to install a watcher for additional instances.
                installOtherInstanceLaunchAttemptWatcher(codeToRunIfOtherInstanceTriesToStart, executeOnAWTEventDispatchThread);
            } else {
                // Only if this is NOT the only instance, it makes sense to create&delete the trigger file that will effect notification of the other instance.
                //
                // Regarding "codeToRunIfOtherInstanceTriesToStart != null":
                // While creation/deletion of the file concerns THE OTHER instance of the program,
                // making it dependent on the call made in THIS instance makes sense
                // because the code executed is probably the same.
                createAndDeleteOtherInstanceWatcherTriggerFile();
            }
        }

        optionallyInstallShutdownHookThatCleansEverythingUp();

        return ret;
    }


    private void createAndDeleteOtherInstanceWatcherTriggerFile() {

        try {
            final RandomAccessFile randomAccessFileForDetection = new RandomAccessFile(DETECTFILE, "rw");
            randomAccessFileForDetection.close();
            Files.deleteIfExists(DETECTFILE.toPath()); // File is created and then instantly deleted. Not a problem for the WatchService :)
        } catch (Exception e) {
            e.printStackTrace();
        }
    }


    private boolean canLockFileBeCreatedAndLocked() {

        try {
            randomAccessFileForLock = new RandomAccessFile(LOCKFILE, "rw");
            fileLock = randomAccessFileForLock.getChannel().tryLock();
            return fileLock != null;
        } catch (Exception e) {
            return false;
        }
    }


    private void installOtherInstanceLaunchAttemptWatcher(final Runnable codeToRunIfOtherInstanceTriesToStart, final boolean executeOnAWTEventDispatchThread) {

        // PREPARE WATCHSERVICE AND STUFF
        try {
            watchService = FileSystems.getDefault().newWatchService();
        } catch (IOException e) {
            e.printStackTrace();
            return;
        }
        final File appFolder = new File("").getAbsoluteFile(); // points to current folder
        final Path appFolderWatchable = appFolder.toPath();


        // REGISTER CURRENT FOLDER FOR WATCHING FOR FILE DELETIONS
        try {
            appFolderWatchable.register(watchService, StandardWatchEventKinds.ENTRY_DELETE);
        } catch (IOException e) {
            e.printStackTrace();
            return;
        }


        // INSTALL WATCHER THAT LOOKS IF OUR detectFile SHOWS UP IN THE DIRECTORY CHANGES. IF THERE'S A CHANGE, ANOTHER INSTANCE TRIED TO START, SO NOTIFY THE CURRENT ONE OF THAT.
        final Thread t = new Thread(() -> watchForDirectoryChangesOnExtraThread(codeToRunIfOtherInstanceTriesToStart, executeOnAWTEventDispatchThread));
        t.setDaemon(true);
        t.setName("directory content change watcher");
        t.start();
    }


    private void optionallyInstallShutdownHookThatCleansEverythingUp() {

        if (fileLock == null && randomAccessFileForLock == null && watchService == null) {
            return;
        }

        final Thread shutdownHookThread = new Thread(() -> {
            try {
                if (fileLock != null) {
                    fileLock.release();
                }
                if (randomAccessFileForLock != null) {
                    randomAccessFileForLock.close();
                }
                Files.deleteIfExists(LOCKFILE.toPath());
            } catch (Exception ignore) {
            }
            if (watchService != null) {
                try {
                    watchService.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        });
        Runtime.getRuntime().addShutdownHook(shutdownHookThread);
    }


    private void watchForDirectoryChangesOnExtraThread(final Runnable codeToRunIfOtherInstanceTriesToStart, final boolean executeOnAWTEventDispatchThread) {

        while (true) { // To eternity and beyond! Until the universe shuts down. (Should be a volatile boolean, but this class only has absolutely required features.)

            try {
                Thread.sleep(POLLINTERVAL);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }


            final WatchKey wk;
            try {
                wk = watchService.poll();
            } catch (ClosedWatchServiceException e) {
                // This situation would be normal if the watcher has been closed, but our application never does that.
                e.printStackTrace();
                return;
            }

            if (wk == null || !wk.isValid()) {
                continue;
            }


            for (WatchEvent<?> we : wk.pollEvents()) {

                final WatchEvent.Kind<?> kind = we.kind();
                if (kind == StandardWatchEventKinds.OVERFLOW) {
                    System.err.println("OVERFLOW of directory change events!");
                    continue;
                }


                final WatchEvent<Path> watchEvent = (WatchEvent<Path>) we;
                final File file = watchEvent.context().toFile();


                if (file.equals(DETECTFILE)) {

                    if (!executeOnAWTEventDispatchThread || SwingUtilities.isEventDispatchThread()) {
                        codeToRunIfOtherInstanceTriesToStart.run();
                    } else {
                        SwingUtilities.invokeLater(codeToRunIfOtherInstanceTriesToStart);
                    }

                    break;

                } else {
                    System.err.println("THIS IS THE FILE THAT WAS DELETED: " + file);
                }

            }

            wk.reset();
        }
    }

}

La bibliothèque Unique4j peut être utilisée pour exécuter une seule instance d'une application Java et transmettre des messages. Vous pouvez le voir sur https://github.com/prat-man/unique4j . Il prend en charge Java 1.6+.

Il utilise une combinaison de verrous de fichiers et de verrous de port dynamiques pour détecter et communiquer entre les instances dans le but principal de n'autoriser qu'une seule instance à s'exécuter.

Voici un exemple simple de la même chose:

import tk.pratanumandal.unique4j.Unique4j;
import tk.pratanumandal.unique4j.exception.Unique4jException;

public class Unique4jDemo {

    // unique application ID
    public static String APP_ID = "tk.pratanumandal.unique4j-mlsdvo-20191511-#j.6";

    public static void main(String[] args) throws Unique4jException, InterruptedException {

        // create unique instance
        Unique4j unique = new Unique4j(APP_ID) {
            @Override
            public void receiveMessage(String message) {
                // display received message from subsequent instance
                System.out.println(message);
            }

            @Override
            public String sendMessage() {
                // send message to first instance
                return "Hello World!";
            }
        };

        // try to obtain lock
        boolean lockFlag = unique.acquireLock();

        // sleep the main thread for 30 seconds to simulate long running tasks
        Thread.sleep(30000);

        // try to free the lock before exiting program
        boolean lockFreeFlag = unique.freeLock();

    }

}

Avis de non-responsabilité: J'ai créé et entretenu la bibliothèque Unique4j.