当前位置：文江博客话题详情

使用进程 ID 和线程 ID 命名目录

发布于 2024-12-06 04:04:37 字数 342 浏览 1 评论 0原文

我有一个应用程序，它有几个线程来操作数据并将输出保存在 Linux 或 Windows 计算机中特定目录的不同临时文件中。这些文件最终需要被删除。

我想做的是能够更好地分离文件，所以我正在考虑通过进程ID和线程ID来做到这一点。这将有助于应用程序节省磁盘空间，因为在线程终止时，可以擦除包含该线程文件的整个目录，并让应用程序的其余部分重新使用相应的磁盘空间。

由于应用程序在 JVM 的单个实例上运行，我假设它将有一个进程 ID，这将是 JVM 的进程 ID，对吧？

既然如此，区分这些文件的唯一方法就是将它们保存在一个文件夹中，该文件夹的名称将与线程 ID 相关。

这种方法合理吗？还是我应该做其他事情？

原文

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

静待花开 2024-12-13 04:04:37

java.io.File 可以为您创建临时文件。只要保留与每个线程关联的文件的列表，就可以在线程退出时删除它们。您还可以将文件标记为退出时删除以防线程未完成。

回复收藏 0 原文

趁年轻赶紧闹 2024-12-13 04:04:37

看来这种方法最简单的解决方案实际上是扩展 Thread - 从未想过我会看到这一天。

正如 PT 已经说过的，只要线程处于活动状态，线程 ID 才是唯一的，它们可以而且肯定会被操作系统重用。

因此，您不必这样做，而是使用可以在构造时指定的线程名称，并且为了简单起见，只需编写一个小类：

public class MyThread extends Thread {
    private static long ID = 0;

    public MyThread(Runnable r) {
        super(r, getNextName());
    }

    private static synchronized String getNextName() {
         // We can get rid of synchronized with some AtomicLong and so on, 
         // doubt that's necessary though
        return "MyThread " + ID++;
    }

}

然后您可以执行如下操作：

public static void main(String[] args) throws InterruptedException {
    Thread t = new MyThread(new Runnable() {
        @Override
        public void run() {
            System.out.println("Name: " + Thread.currentThread().getName());
        }
    });
    t.start();
}

您必须覆盖要使用的所有构造函数，并且始终使用 MyThread 类，但这样您就可以保证唯一的映射 - 至少 2^64-1 （毕竟负值也可以），这应该足够了。

尽管我仍然不认为这是最好的方法，可能更好地创建一些“作业”类，其中包含所有必要的信息，并且可以在不再需要时立即清理其文件 - 这样你就可以还可以轻松使用 ThreadPools 和 co，其中一个线程可以完成多项工作。目前，您在线程中拥有业务逻辑 - 这对我来说并不是特别好的设计。

It seems the simplest solution for this approach is really to extend Thread - never thought I'd see that day.

As P.T. already said Thread IDs are only unique as long as the thread is alive, they can and most certainly will be reused by the OS.

So instead of doing it this way, you use the Thread name that can be specified at construction and to make it simple, just write a small class:

public class MyThread extends Thread {
    private static long ID = 0;

    public MyThread(Runnable r) {
        super(r, getNextName());
    }

    private static synchronized String getNextName() {
         // We can get rid of synchronized with some AtomicLong and so on, 
         // doubt that's necessary though
        return "MyThread " + ID++;
    }

}

Then you can do something like this:

public static void main(String[] args) throws InterruptedException {
    Thread t = new MyThread(new Runnable() {
        @Override
        public void run() {
            System.out.println("Name: " + Thread.currentThread().getName());
        }
    });
    t.start();
}

You have to overwrite all constructors you want to use and always use the MyThread class, but this way you can guarantee a unique mapping - well at least 2^64-1 (negative values are fine too after all) which should be more than enough.

Though I still don't think that's the best approach, possibly better to create some "job" class that contains all necessary information and can clean up its files as soon as it's no longer needed - that way you also can easily use ThreadPools and co where one thread will do more than one job. At the moment you have business logic in a thread - that doesn't strike me as especially good design.

回复收藏 0 原文