WatchService有时触发ENTRY_MODIFY两次，有时触发一次

Question

我正在使用Oracle的WatchService示例:

import java.nio.file.*;
import static java.nio.file.StandardWatchEventKinds.*;
import static java.nio.file.LinkOption.*;
import java.nio.file.attribute.*;
import java.io.*;
import java.util.*;
public class WatchDir {
private final WatchService watcher;
private final Map<WatchKey,Path> keys;
private final boolean recursive;
private boolean trace = false;
@SuppressWarnings("unchecked")
static <T> WatchEvent<T> cast(WatchEvent<?> event) {
    return (WatchEvent<T>)event;
}
/**
 * Register the given directory with the WatchService
 */
private void register(Path dir) throws IOException {
    WatchKey key = dir.register(watcher, ENTRY_CREATE, ENTRY_DELETE, ENTRY_MODIFY);
    if (trace) {
        Path prev = keys.get(key);
        if (prev == null) {
            System.out.format("register: %sn", dir);
        } else {
            if (!dir.equals(prev)) {
                System.out.format("update: %s -> %sn", prev, dir);
            }
        }
    }
    keys.put(key, dir);
}
/**
 * Register the given directory, and all its sub-directories, with the
 * WatchService.
 */
private void registerAll(final Path start) throws IOException {
    // register directory and sub-directories
    Files.walkFileTree(start, new SimpleFileVisitor<Path>() {
        @Override
        public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs)
                throws IOException
        {
            register(dir);
            return FileVisitResult.CONTINUE;
        }
    });
}
/**
 * Creates a WatchService and registers the given directory
 */
WatchDir(Path dir, boolean recursive) throws IOException {
    this.watcher = FileSystems.getDefault().newWatchService();
    this.keys = new HashMap<WatchKey,Path>();
    this.recursive = recursive;
    if (recursive) {
        System.out.format("Scanning %s ...n", dir);
        registerAll(dir);
        System.out.println("Done.");
    } else {
        register(dir);
    }
    // enable trace after initial registration
    this.trace = true;
}
/**
 * Process all events for keys queued to the watcher
 */
void processEvents() {
    for (;;) {
        // wait for key to be signalled
        WatchKey key;
        try {
            key = watcher.take();
        } catch (InterruptedException x) {
            return;
        }
        Path dir = keys.get(key);
        if (dir == null) {
            System.err.println("WatchKey not recognized!!");
            continue;
        }
        for (WatchEvent<?> event: key.pollEvents()) {
            WatchEvent.Kind kind = event.kind();
            // TBD - provide example of how OVERFLOW event is handled
            if (kind == OVERFLOW) {
                continue;
            }
            // Context for directory entry event is the file name of entry
            WatchEvent<Path> ev = cast(event);
            Path name = ev.context();
            Path child = dir.resolve(name);
            // print out event
            System.out.format("%s: %sn", event.kind().name(), child);
            // if directory is created, and watching recursively, then
            // register it and its sub-directories
            if (recursive && (kind == ENTRY_CREATE)) {
                try {
                    if (Files.isDirectory(child, NOFOLLOW_LINKS)) {
                        registerAll(child);
                    }
                } catch (IOException x) {
                    // ignore to keep sample readbale
                }
            }
        }
        // reset key and remove from set if directory no longer accessible
        boolean valid = key.reset();
        if (!valid) {
            keys.remove(key);
            // all directories are inaccessible
            if (keys.isEmpty()) {
                break;
            }
        }
    }
}
static void usage() {
    System.err.println("usage: java WatchDir [-r] dir");
    System.exit(-1);
}
public static void main(String[] args) throws IOException {
    // parse arguments
    if (args.length == 0 || args.length > 2)
        usage();
    boolean recursive = false;
    int dirArg = 0;
    if (args[0].equals("-r")) {
        if (args.length < 2)
            usage();
        recursive = true;
        dirArg++;
    }
    // register directory and process its events
    Path dir = Paths.get(args[dirArg]);
    new WatchDir(dir, recursive).processEvents();
}
}

我正在Windows 7中开发一个应用程序，部署环境是rhel 7.2。起初，在两个操作系统中，每当我复制一个文件时，它都会触发一个ENTRY_CREATED，然后是两个ENTRY_MODIFY。第一个ENTRY_MODIFY在复制开始时，第二个ENTRY_MODIFY在复制结束时。所以我知道复制过程已经结束了。然而，它现在只在rhel 7.2中触发一个ENTRY_MODIFY。它仍然在Windows 7中触发两个ENTRY_MODIFY事件。

我在stackoverflow中发现了这一点。这个问题问的是为什么两个ENTRY_MODIFY被解雇了。这不完全是我的问题，但它的一个答案与我的问题有争议。遗憾的是，在这场争论中，我的问题没有解决办法。

因为在拷贝的末尾没有ENTRY_MODIFY被触发，只有在拷贝的开始，所以我不知道什么时候完成拷贝。你认为这可能是什么原因?可以修复吗，我怎么知道复印完成了?我不能改变rhel 7.2，但除此之外的任何东西我都很乐意接受。

Answer 1

我只是检查文件长度是否为零。这里有一个

的例子

for (WatchEvent<?> event : key.pollEvents()) {
    Path fileName = (Path) event.context();
    if("tomcat-users.xml".equals(fileName.toString())) {
        Path tomcatUsersXml = tomcatConf.resolve(fileName);
        if(tomcatUsersXml.toFile().length() > 0) {
            load(tomcatUsersXml);
        }
    } 
}

Answer 2

您可以使用DelayQueue来删除事件。