Запретить запуск нескольких экземпляров Java-приложения

Я боролся с этой той же проблемой, некоторое время... ни одна из идей, представленных здесь, не работала на меня. Во всех случаях блокировка (файл, сокет или иначе) не сохранялась в 2-й экземпляр процесса, таким образом, 2-й экземпляр все еще работал.

, Таким образом, я решил попробовать старый школьный подход для простой упаковки в ящики .pid файла с идентификатором процесса первого процесса. Тогда любой 2-й процесс вышел бы, если он находит .pid файл, и также число процесса, определенное в файле, подтверждено для тихого выполнения. Этот подход работал на меня.

существует немного кода, который я предоставляю здесь полностью для Вашего использования... полное решение.

package common.environment;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import java.io.*;
import java.nio.charset.Charset;

public class SingleAppInstance
{
    private static final @Nonnull Logger log = LogManager.getLogger(SingleAppInstance.class.getName());

    /**
     * Enforces that only a single instance of the given component is running. This
     * is resilient to crashes, unexpected reboots and other forceful termination
     * scenarios.
     *
     * @param componentName = Name of this component, for disambiguation with other
     *   components that may run simultaneously with this one.
     * @return = true if the program is the only instance and is allowed to run.
     */
    public static boolean isOnlyInstanceOf(@Nonnull String componentName)
    {
        boolean result = false;

        // Make sure the directory exists
        String dirPath = getHomePath();
        try
        {
            FileUtil.createDirectories(dirPath);
        }
        catch (IOException e)
        {
            throw new RuntimeException(String.format("Unable to create directory: [%s]", dirPath));
        }

        File pidFile = new File(dirPath, componentName + ".pid");

        // Try to read a prior, existing pid from the pid file. Returns null if the file doesn't exist.
        String oldPid = FileUtil.readFile(pidFile);

        // See if such a process is running.
        if (oldPid != null && ProcessChecker.isStillAllive(oldPid))
        {
            log.error(String.format("An instance of %s is already running", componentName));
        }
        // If that process isn't running, create a new lock file for the current process.
        else
        {
            // Write current pid to the file.
            long thisPid = ProcessHandle.current().pid();
            FileUtil.createFile(pidFile.getAbsolutePath(), String.valueOf(thisPid));

            // Try to be tidy. Note: This won't happen on exit if forcibly terminated, so we don't depend on it.
            pidFile.deleteOnExit();

            result = true;
        }

        return result;
    }

    public static @Nonnull String getHomePath()
    {
        // Returns a path like C:/Users/Person/
        return System.getProperty("user.home") + "/";
    }
}

class ProcessChecker
{
    private static final @Nonnull Logger log = LogManager.getLogger(io.cpucoin.core.platform.ProcessChecker.class.getName());

    static boolean isStillAllive(@Nonnull String pidStr)
    {
        String OS = System.getProperty("os.name").toLowerCase();
        String command;
        if (OS.contains("win"))
        {
            log.debug("Check alive Windows mode. Pid: [{}]", pidStr);
            command = "cmd /c tasklist /FI \"PID eq " + pidStr + "\"";
        }
        else if (OS.contains("nix") || OS.contains("nux"))
        {
            log.debug("Check alive Linux/Unix mode. Pid: [{}]", pidStr);
            command = "ps -p " + pidStr;
        }
        else
        {
            log.warn("Unsupported OS: Check alive for Pid: [{}] return false", pidStr);
            return false;
        }
        return isProcessIdRunning(pidStr, command); // call generic implementation
    }

    private static boolean isProcessIdRunning(@Nonnull String pid, @Nonnull 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;
            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;
        }
    }
}

class FileUtil
{
    static void createDirectories(@Nonnull String dirPath) throws IOException
    {
        File dir = new File(dirPath);
        if (dir.mkdirs())   /* If false, directories already exist so nothing to do. */
        {
            if (!dir.exists())
            {
                throw new IOException(String.format("Failed to create directory (access permissions problem?): [%s]", dirPath));
            }
        }
    }

    static void createFile(@Nonnull String fullPathToFile, @Nonnull String contents)
    {
        try (PrintWriter writer = new PrintWriter(fullPathToFile, Charset.defaultCharset()))
        {
            writer.print(contents);
        }
        catch (IOException e)
        {
            throw new RuntimeException(String.format("Unable to create file at %s! %s", fullPathToFile, e.getMessage()), e);
        }
    }

    static @Nullable String readFile(@Nonnull File file)
    {
        try
        {
            try (BufferedReader fileReader = new BufferedReader(new FileReader(file)))
            {
                StringBuilder result = new StringBuilder();

                String line;
                while ((line = fileReader.readLine()) != null)
                {
                    result.append(line);
                    if (fileReader.ready())
                        result.append("\n");
                }
                return result.toString();
            }
        }
        catch (IOException e)
        {
            return null;
        }
    }
}

Для использования его просто вызовите его как это:

if (!SingleAppInstance.isOnlyInstanceOf("my-component"))
{
    // quit
}

я надеюсь, что Вы находите это полезным.