Datei Beobachten: Wie gehe ich am besten vor?

package de.tutorials;

import java.io.File;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class FileSystemWatcher {
	Map<String, FileInfo> snapshot = new ConcurrentHashMap<String, FileInfo>();
	volatile boolean stop;
	volatile List<File> watchedResources = new CopyOnWriteArrayList<File>();

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		new FileSystemWatcher().add("c:/temp/watch").start();

	}

	public FileSystemWatcher add(String resource) {
		File file = new File(resource);

		watchedResources.add(file);

		snapshot.putAll(snapshot(file));

		return this;
	}

	protected Map<String, FileInfo> snapshot(File file) {
		Map<String, FileInfo> map = new ConcurrentHashMap<String, FileInfo>();

		map.put(file.getAbsolutePath(), new FileInfo(file));

		//Recursive? 
		if (file.isDirectory()) {
			for (File item : file.listFiles()) {
				map.put(item.getAbsolutePath(), new FileInfo(item));
			}
		}

		return map;
	}

	public FileSystemWatcher start() {
		Executors.newSingleThreadExecutor().execute(createWatchThread());
		return this;
	}

	public void stop() {
		this.stop = true;
	}

	public Runnable createWatchThread() {
		return new Runnable() {
			public void run() {
				while (!stop) {
					for (File watchedResource : watchedResources) {
						Map<String, FileInfo> current = snapshot(watchedResource);
						checkForModifications(snapshot, current);
					}

					try {
						TimeUnit.SECONDS.sleep(1);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}

					// System.out.println(snapshot);
				}

				System.out.println("Stop watching resources: " + watchedResources);
			}
		};
	}

	public void checkForModifications(Map<String, FileInfo> snapshot, Map<String, FileInfo> current) {

		Set<String> newEntries = new HashSet<String>(current.keySet());
		newEntries.removeAll(snapshot.keySet());

		for (String newResource : newEntries) {
			System.out.println("New: " + newResource);
			snapshot.put(newResource, current.get(newResource));
		}

		for (Map.Entry<String, FileInfo> snapshotEntry : snapshot.entrySet()) {
			FileInfo snapshotFileInfo = snapshotEntry.getValue();
			FileInfo currentFileInfo = current.get(snapshotEntry.getKey());

			if (currentFileInfo == null) {
				System.out.println("deleted: " + snapshotEntry.getKey());
				snapshot.remove(snapshotEntry.getKey());
			} else {
				boolean modified = false;
				
				if (snapshotFileInfo.size != currentFileInfo.size) {
					System.out.println("modified (size): " + currentFileInfo);
					modified = true;
				} 

				//touch?
				if (snapshotFileInfo.lastModified != currentFileInfo.lastModified) {
					System.out.println("modified (time): " + currentFileInfo);
					modified = true;
				}

				if (modified) {
					snapshot.put(snapshotEntry.getKey(), currentFileInfo);
				}
			}
		}

	}
	
	static class FileInfo {
		String name;
		String location;
		long lastModified;
		long size;

		public FileInfo(File file) {
			this.name = file.getName();
			this.location = file.getParent();
			this.lastModified = file.lastModified();
			this.size = file.length();
		}

		@Override
		public String toString() {
			return "FileInfo [name=" + name + ", location=" + location + ", size=" + size + ", lastModified=" + lastModified + "]";
		}
	}
}