我们可以在java中使用多线程概念和WatchService API吗？

假设我有一个目录，在其中我将把多个传入文件放入该目录。我需要根据文件创建时间处理所有文件，即首先处理第一个创建的文件

为了监视目录，我实现了WatchService API

---

我们如何根据创建日期对目录中的文件进行排序？我们可以在这里实现多线程概念吗？

实际上只是一个框架，但它应该让您开始。它会编译，但不会做任何事情

当看到新文件进入时，将其添加到队列的末尾。使用executor服务创建的4个线程正在等待处理文件。一旦其中一个线程进入，一个线程就会将其拾取并开始处理。如果它们都很忙，下一个文件将不得不等待，但仍将按照它们进入的顺序进行处理

我不确定睡觉是不是个好主意。我想这取决于你多久收到一次文件

import java.io.File;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class FileWatcher //implements WatchService
{
    private class FileProcessor implements Runnable
    {
        @Override
        public void run()
        {
            while(!Thread.currentThread().isInterrupted())
            {
                try
                {
                    File file = fileQueue.take(); // blocks
                    process(file);
                }
                catch (InterruptedException ex)
                {
                    ex.printStackTrace();
                }
                // maybe sleep for a bit here (exponential backoff?)
            }
        }

        private void process(File file)
        {
            // do some stuff
        }
    }

    private static final int NUM_THREADS = 4;
    private static final int QUEUE_SIZE  = 1000;

    private final BlockingQueue<File> fileQueue = new ArrayBlockingQueue<>(QUEUE_SIZE);

    public FileWatcher()
    {
        // Create our 4 processors
        ExecutorService executorService = Executors.newFixedThreadPool(NUM_THREADS);

        for(int i = 0; i < NUM_THREADS; ++i)
        {
            executorService.execute(new FileProcessor());
        }
    }

    // When a file comes in to your WatchService
    private void onNewFile(File file)
    {
        fileQueue.add(file);
    }
}

导入java.io.File；
导入java.util.concurrent.ArrayBlockingQueue；
导入java.util.concurrent.BlockingQueue；
导入java.util.concurrent.ExecutorService；
导入java.util.concurrent.Executors；
公共类FileWatcher//实现WatchService
{
私有类FileProcessor实现可运行
{
@凌驾
公开募捐
{
而（！Thread.currentThread（）.isInterrupted（））
{
尝试
{
File File=fileQueue.take（）；//块
过程（文件）；
}
捕获（中断异常例外）
{
例如printStackTrace（）；
}
//也许在这里睡一会儿（指数退避？）
}
}
私有无效进程（文件）
{
//做点什么
}
}
私有静态final int NUM_THREADS=4；
私有静态最终int队列_SIZE=1000；
private final BlockingQueue fileQueue=新的ArrayBlockingQueue（队列大小）；
公共文件监视程序（）
{
//创建我们的4个处理器
ExecutorService ExecutorService=Executors.newFixedThreadPool（NUM_线程）；
对于（int i=0；i

实际上只是一个框架，但它应该让你开始。它会编译，但不会做任何事情

当看到新文件进入时，将其添加到队列的末尾。使用executor服务创建的4个线程正在等待处理文件。一旦其中一个线程进入，一个线程就会将其拾取并开始处理。如果它们都很忙，下一个文件将不得不等待，但仍将按照它们进入的顺序进行处理

我不确定睡觉是不是个好主意。我想这取决于你多久收到一次文件

import java.io.File;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class FileWatcher //implements WatchService
{
    private class FileProcessor implements Runnable
    {
        @Override
        public void run()
        {
            while(!Thread.currentThread().isInterrupted())
            {
                try
                {
                    File file = fileQueue.take(); // blocks
                    process(file);
                }
                catch (InterruptedException ex)
                {
                    ex.printStackTrace();
                }
                // maybe sleep for a bit here (exponential backoff?)
            }
        }

        private void process(File file)
        {
            // do some stuff
        }
    }

    private static final int NUM_THREADS = 4;
    private static final int QUEUE_SIZE  = 1000;

    private final BlockingQueue<File> fileQueue = new ArrayBlockingQueue<>(QUEUE_SIZE);

    public FileWatcher()
    {
        // Create our 4 processors
        ExecutorService executorService = Executors.newFixedThreadPool(NUM_THREADS);

        for(int i = 0; i < NUM_THREADS; ++i)
        {
            executorService.execute(new FileProcessor());
        }
    }

    // When a file comes in to your WatchService
    private void onNewFile(File file)
    {
        fileQueue.add(file);
    }
}

导入java.io.File；
导入java.util.concurrent.ArrayBlockingQueue；
导入java.util.concurrent.BlockingQueue；
导入java.util.concurrent.ExecutorService；
导入java.util.concurrent.Executors；
公共类FileWatcher//实现WatchService
{
私有类FileProcessor实现可运行
{
@凌驾
公开募捐
{
而（！Thread.currentThread（）.isInterrupted（））
{
尝试
{
File File=fileQueue.take（）；//块
过程（文件）；
}
捕获（中断异常例外）
{
例如printStackTrace（）；
}
//也许在这里睡一会儿（指数退避？）
}
}
私有无效进程（文件）
{
//做点什么
}
}
私有静态final int NUM_THREADS=4；
私有静态最终int队列_SIZE=1000；
private final BlockingQueue fileQueue=新的ArrayBlockingQueue（队列大小）；
公共文件监视程序（）
{
//创建我们的4个处理器
ExecutorService ExecutorService=Executors.newFixedThreadPool（NUM_线程）；
对于（int i=0；i

多线程当然是可能的。假设创建了

File1

，然后在

File2

之后不久，您是否关心

File2

是否在

File1

之前完成处理？（也许

File2

要小得多或者其他什么）不，我不在乎File2的处理时间。您能在这里编辑示例代码吗。@Michael，我有一个类似的概念，我查看了您的解决方案，想知道WatchService API在您的解决方案中的位置？。我已经在使用watch服务，它可以完美地处理第一个文件，但是程序在读取下一个文件时退出，即使detectMulti-threading肯定是可能的。假设创建了

File1

，然后在

File2

之后不久，您是否关心

File2

是否在

File1

之前完成处理？（也许

File2

要小得多或者其他什么）不，我不在乎File2的处理时间。您能在这里编辑示例代码吗。@Michael，我有一个类似的概念，我查看了您的解决方案，想知道WatchService API在您的解决方案中的位置？。我已经在使用watch服务，它可以完美地处理第一个文件，但是程序会在读取下一个文件时退出detect@dev777请问这项决议是否对你有帮助？我正在为一个类似的概念而挣扎，似乎无法理解