Why does WatchService generate so many operations?

java, java-7, nio, watchservice

Solution

Watch Service's Modify event generates two events. When we modify an already existing file, the file system first creates it with 0 bytes and fires a modify event and then writes data on it. Then it fires the modify event again. That's why It was showing two modify events. So What I have done to solve this problem, I just use counter to check my task should be triggered only once on even count

        Path path = null;
        int count = 0;

        try {
            path = Paths.get(new Utility().getConfDirPath());
            System.out.println("Path: " + path);
        } catch (UnsupportedEncodingException e1) {
            e1.printStackTrace();
        }

        WatchService watchService = null;
        try {
            watchService = FileSystems.getDefault().newWatchService();
            path.register(watchService, StandardWatchEventKinds.ENTRY_MODIFY,StandardWatchEventKinds.ENTRY_DELETE);
        } catch (IOException ioe) {
            ioe.printStackTrace();
        }


        while(true) {
            WatchKey key = null;
            try {
                key = watchService.take();
            } catch(InterruptedException ie) {
                ie.printStackTrace();
            }

            for(WatchEvent<?> event: key.pollEvents()) {
                switch(event.kind().name()) {
                    case "ENTRY_MODIFY":
                        System.out.println(++count + ": File " + event.context() + " is changed!");

                        if (count%2==0) {
                            doOnChange(); // do whatever you want
                        }
                        break;
                    case "ENTRY_DELETE":
                        System.out.println(++count + ": File " + event.context() + " is deleted!");
                        break;
                    default:
                        System.out.println(++count + ": UNKNOWN EVENT!");
                }
            }

            // reset the key
            boolean valid = key.reset();
            if (!valid) {
                System.out.println("Key has been unregistered");
            }

        }

Problem

``` import java.io.*; import java.nio.file.*; public class Tmp { public static void main(String [] args) throws IOException { int count = 0; Path path = Paths.get("C:\\tmp\\"); WatchService ws = null; try { ws = FileSystems.getDefault().newWatchService(); path.register(ws, StandardWatchEventKinds.ENTRY_CREATE, StandardWatchEventKinds.ENTRY_DELETE, StandardWatchEventKinds.ENTRY_MODIFY, StandardWatchEventKinds.OVERFLOW); } catch (IOException ioe) { ioe.printStackTrace(); } while(true) { WatchKey key = null; try { key = ws.take(); } catch(InterruptedException ie) { ie.printStackTrace(); } for(WatchEvent<?> event: key.pollEvents()) { switch(event.kind().name()) { case "OVERFLOW": System.out.println(++count + ": OVERFLOW"); break; case "ENTRY_MODIFY": System.out.println(++count + ": File " + event.context() + " is changed!"); break; case "ENTRY_CREATE": System.out.println(++count + ": File " + event.context() + " is created!"); break; case "ENTRY_DELETE": System.out.println(++count + ": File " + event.context() + " is deleted!"); break; default: System.out.println(++count + ": UNKNOWN EVENT!"); } } key.reset(); } } } ``` When I run this and then opened the Notepad++ and then created a new empty file and saved it as `a.txt` in the `C:\tmp\` directory I got the output: ``` 1: File a.txt is created! 2: File a.txt is deleted! 3: File a.txt is created! ``` Why is that? It looks like the file was created and then deleted and then created again. Why? When I put some text in the file and saved it the output was: ``` 4: File a.txt is changed! 5: File a.txt is changed! ``` Why did it change twice?

Original source