90

有时我看到许多应用程序，例如 msn、windows media player 等都是单实例应用程序（当用户在应用程序运行时执行时，不会创建新的应用程序实例）。

在 C# 中，我Mutex为此使用类，但我不知道如何在 Java 中执行此操作。

4

17 回答 17

67

我在主要方法中使用以下方法。这是我见过的最简单、最健壮、侵入性最小的方法，所以我想我会分享它。

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;
}
于 2010-01-04T23:07:16.353 回答
62

如果我相信这篇文章，作者：

让第一个实例尝试在 localhost 接口上打开一个侦听套接字。如果它能够打开套接字，则假定这是要启动的应用程序的第一个实例。如果不是，则假设此应用程序的一个实例已经在运行。新实例必须通知现有实例已尝试启动，然后退出。现有实例在收到通知后接管并向处理该操作的侦听器触发事件​​。

注意：阿赫在评论中提到使用InetAddress.getLocalHost()可能很棘手：

  • 它在 DHCP 环境中无法按预期工作，因为返回的地址取决于计算机是否具有网络访问权限。
    解决方案是打开连接InetAddress.getByAddress(new byte[] {127, 0, 0, 1})；
    可能与错误 4435662有关。
  • 我还发现错误 4665037报告的结果比预期的结果getLocalHost：返回机器的 IP 地址与实际结果：返回127.0.0.1。

令人惊讶的是在 Linux 上有getLocalHost回报127.0.0.1，但在 Windows 上没有回报。

或者你可以使用ManagementFactory对象。如此处所述：

该getMonitoredVMs(int processPid)方法接收当前应用程序的PID作为参数，并捕获从命令行调用的应用程序名称，例如应用程序是从c:\java\app\test.jar路径启动的，则值变量为“ c:\\java\\app\\test.jar”。这样，我们将在下面代码的第 17 行捕获应用程序名称。
之后，我们在JVM中搜索另一个同名的进程，如果我们找到了它并且应用程序PID不同，则表示这是第二个应用程序实例。

JNLP 还提供了一个SingleInstanceListener

于 2008-10-07T04:01:38.400 回答
11

如果应用程序。有一个 GUI，使用 JWS 启动它并使用SingleInstanceService.

更新

Java 插件（applet 和 JWS 应用程序都需要）已被 Oracle 弃用并从 JDK 中删除。浏览器制造商已经从他们的浏览器中删除了它。

所以这个答案已经失效。仅将其留在这里以警告查看旧文档的人。

于 2011-08-24T14:04:53.303 回答
6

是的，对于 eclipse RCP 来说，这是一个非常不错的答案 下面是我的代码 eclipse 单实例应用程序

在 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;
}
于 2010-11-23T13:39:14.130 回答
5

我们为此使用文件锁定（在用户的应用程序数据目录中的魔术文件上获取排他锁），但我们主要感兴趣的是防止多个实例运行。

如果您试图让第二个实例将命令行参数等传递给第一个实例，那么在 localhost 上使用套接字连接将用一块石头杀死两只鸟。通用算法：

  • 启动时，尝试在本地主机上的端口 XXXX 上打开侦听器
  • 如果失败，则在 localhost 上打开该端口的写入器并发送命令行参数，然后关闭
  • 否则，在 localhost 上监听端口 XXXX。当收到命令行参数时，处理它们就像应用程序是使用该命令行启动的一样。
于 2008-10-07T04:26:34.543 回答
5

我找到了一个解决方案，有点卡通化的解释，但在大多数情况下仍然有效。它使用普通的旧锁文件创建东西，但视图完全不同：

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

我认为这将有助于那些有严格防火墙设置的人。

于 2009-05-16T12:53:35.857 回答
5

您可以使用 JUnique 库。它提供对运行单实例 java 应用程序的支持，并且是开源的。

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

JUnique 库可用于防止用户同时运行同一 Java 应用程序的多个实例。

JUnique 实现了在同一用户启动的所有 JVM 实例之间共享的锁和通信通道。

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

在后台，它在 %USER_DATA%/.junique 文件夹中创建文件锁，并在随机端口为每个唯一的 appId 创建一个服务器套接字，允许在 java 应用程序之间发送/接收消息。

于 2016-11-23T11:31:29.557 回答
4

在 Windows 上，您可以使用launch4j。

于 2008-10-07T09:01:11.323 回答
3

J2SE 5.0 或更高版本中支持的 ManagementFactory 类详细信息

但现在我使用 J2SE 1.4，我发现了这个http://audiprimadhanty.wordpress.com/2008/06/30/ensuring-one-instance-of-application-running-at-one-time/但我从不测试。你怎么看待这件事？

于 2008-10-07T06:02:04.053 回答
2

您可以打开一个内存映射文件，然后查看该文件是否已经打开。如果它已经打开，您可以从 main 返回。

其他方法是使用锁定文件（标准 unix 实践）。另一种方法是在检查剪贴板中是否已经存在某些内容后，在 main 启动时将某些内容放入剪贴板。

否则，您可以以侦听模式（ServerSocket）打开套接字。首先尝试连接到hte socket；如果无法连接，则打开一个 serversocket。如果您连接，那么您知道另一个实例已经在运行。

因此，几乎任何系统资源都可用于了解应用程序正在运行。

BR，~A

于 2008-10-07T04:33:40.723 回答
2

您可以尝试使用 Preferences API。它独立于平台。

于 2008-10-07T08:58:06.803 回答
2

我为此使用了套接字，并且根据应用程序是在客户端还是服务器端，行为会有所不同：

  • 客户端：如果实例已经存在（我无法监听特定端口），我将传递应用程序参数并退出（您可能希望在前一个实例中执行一些操作）如果不存在，我将启动应用程序。
  • 服务器端：如果实例已经存在，我将打印一条消息并退出，否则我将启动应用程序。
于 2009-05-16T19:49:55.573 回答
2

限制单台机器甚至整个网络上的实例数量的更通用方法是使用多播套接字。

使用多播套接字，您可以将消息广播到应用程序的任意数量的实例，其中一些实例可以位于公司网络上的物理远程计算机上。

通过这种方式，您可以启用多种类型的配置，以控制诸如

  • 每台机器一个或多个实例
  • 每个网络一个或多个实例（例如控制客户端站点上的安装）

Java 的多播支持是通过java.net 包实现的，其中MulticastSocket和DatagramSocket是主要工具。

注意：MulticastSocket 不保证数据包的传送，因此您应该使用构建在多播套接字之上的工具，例如JGroups。JGroups确实保证所有数据的交付。它是一个 jar 文件，具有非常简单的 API。

JGroups 已经存在了一段时间，并且在工业中有一些令人印象深刻的用途，例如它支持 JBoss 的集群机制，将数据广播到集群的所有实例。

要使用 JGroups，限制应用程序实例的数量（在机器或网络上，比如说：客户购买的许可证数量）在概念上非常简单：

  • 在您的应用程序启动时，每个实例都会尝试加入一个命名组，例如“My Great App Group”。您将已将此组配置为允许 0、1 或 N 个成员
  • 当组成员数量大于您为其配置的数量时..您的应用程序应该拒绝启动。
于 2016-04-22T08:53:30.490 回答
2

Unique4j 库可用于运行 Java 应用程序的单个实例并传递消息。你可以在https://github.com/prat-m​​an/unique4j看到它。它支持 Java 1.6+。

它使用文件锁和动态端口锁的组合来检测实例之间并进行通信，其主要目标是只允许一个实例运行。

下面是一个简单的例子：

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();

    }

}

免责声明：我创建并维护了 Unique4j 库。

于 2019-11-17T18:40:56.340 回答
1 
公共类 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";
    私有静态 JFrame 框架 = null;

    公共静态无效主要（字符串[]参数）{
        尝试 {
            FileChannel lockChannel = new RandomAccessFile(LOCK, "rw").getChannel();
            文件锁 flk = null;
            尝试 {
                flk = lockChannel.tryLock();
            } 捕捉（可投掷的 t）{
                t.printStackTrace();
            }
            if (flk == null || !flk.isValid()) {
                System.out.println("已经运行，给管道留言并退出...");
                FileChannel pipeChannel = null;
                尝试 {
                    pipeChannel = new RandomAccessFile(PIPE, "rw").getChannel();
                    MappedByteBuffer bb = pipeChannel.map(FileChannel.MapMode.READ_WRITE, 0, 1);
                    bb.put(0, (byte)1);
                    bb.force();
                } 捕捉（可投掷的 t）{
                    t.printStackTrace();
                } 最后 {
                    如果（管道通道！= null）{
                        尝试 {
                            pipeChannel.close();
                        } 捕捉（可投掷的 t）{
                            t.printStackTrace();
                        }
                    }
                }
                System.exit(0);
            }
            //这里我们不释放锁关闭通道，
            // 这将在应用程序崩溃或正常关闭后完成。
            SwingUtilities.invokeLater(
                新的可运行（）{
                    公共无效运行（）{
                        createAndShowGUI();
                    }
                }
            );

            FileChannel pipeChannel = null;
            尝试 {
                pipeChannel = new RandomAccessFile(PIPE, "rw").getChannel();
                MappedByteBuffer bb = pipeChannel.map(FileChannel.MapMode.READ_WRITE, 0, 1);
                而（真）{
                    字节 b = bb.get(0);
                    如果 (b > 0) {
                        bb.put(0, (byte)0);
                        bb.force();
                        SwingUtilities.invokeLater(
                            新的可运行（）{
                                公共无效运行（）{
                                    frame.setExtendedState(JFrame.NORMAL);
                                    frame.setAlwaysOnTop(true);
                                    frame.toFront();
                                    frame.setAlwaysOnTop(false);
                                }
                            }
                        );
                    }
                    线程.sleep(1000);
                }
            } 捕捉（可投掷的 t）{
                t.printStackTrace();
            } 最后 {
                如果（管道通道！= null）{
                    尝试 {
                        pipeChannel.close();
                    } 捕捉（可投掷的 t）{
                        t.printStackTrace();
                    }
                }
            }
        } 捕捉（可投掷的 t）{
            t.printStackTrace();
        }
    }

    公共静态无效createAndShowGUI（）{

        框架 = 新的 JFrame();
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setSize(800, 650);
        frame.getContentPane().add(new JLabel("主窗口",
                    SwingConstants.CENTER), BorderLayout.CENTER);
        frame.setLocationRelativeTo(null);
        frame.setVisible(true);
    }
}
于 2014-05-12T16:13:01.607 回答
1

编辑：可以使用一个简单的 1 秒计时器线程来检查 indicatorFile.exists()，而不是使用这种 WatchService 方法。删除它，然后将应用程序带到Front()。

编辑：我想知道为什么这被否决了。这是迄今为止我见过的最好的解决方案。例如，如果另一个应用程序碰巧已经在监听该端口，那么服务器套接字方法就会失败。

只需下载 Microsoft Windows Sysinternals TCPView（或使用 netstat），启动它，按“状态”排序，查找显示“LISTENING”的行块，选择远程地址为您的计算机名称的行块，将该端口放入您的新套接字（）-解决方案。在我的实现中，我每次都会产生失败。这是合乎逻辑的，因为它是该方法的基础。或者我没有得到关于如何实现这一点的信息？

请告诉我是否以及我对此有何错误！

我的观点——如果可能的话，我要求你反驳——建议开发人员在生产代码中使用一种方法，这种方法在大约 60000 个案例中至少有 1 个会失败。如果这种观点恰好是正确的，那么绝对不会因为所提出的解决方案没有这个问题而被否决并因其代码量而受到批评。

比较套接字方法的缺点：

  • 如果选择了错误的彩票（端口号），则失败。
  • 多用户环境下失败：只有一个用户可以同时运行应用程序。（我的方法必须稍微改变才能在用户树中创建文件，但这很简单。）
  • 如果防火墙规则过于严格，则会失败。
  • 让可疑的用户（我在野外遇到过）想知道当您的文本编辑器声明服务器套接字时您在做什么恶作剧。

我刚刚对如何以适用于每个系统的方式解决新实例到现有实例的 Java 通信问题有了一个好主意。所以，我在大约两个小时内完成了这门课。像魅力一样工作：D

它基于Robert的文件锁定方法（也在此页面上），从那时起我就一直在使用它。告诉已经运行的实例另一个实例试图启动（但没有）...创建一个文件并立即删除，第一个实例使用 WatchService 检测此文件夹内容更改。考虑到问题的根本性，我不敢相信这显然是一个新想法。

这可以很容易地更改为只创建而不是删除文件，然后可以将信息放入其中，以便适当的实例可以评估，例如命令行参数 - 然后适当的实例可以执行删除。就个人而言，我只需要知道何时恢复我的应用程序的窗口并将其发送到前面。

示例使用：

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.");
}

这是课程：

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

}
于 2016-04-21T14:19:21.383 回答
1

我为此编写了一个专用库https://sanyarnd.github.io/applocker

它基于文件通道锁定，因此它不会阻塞端口号，或者在断电的情况下死锁应用程序（一旦进程终止，通道就会被释放）。

库本身是轻量级的，并且具有流畅的 API。

它的灵感来自http://www.sauronsoftware.it/projects/junique/，但它是基于文件通道的。还有其他额外的新功能。

于 2020-11-06T22:06:05.903 回答