WatchServiceIt is an API provided in the Java NIO package () for monitoring file system changes. It allows applications to listen for file creation, modification, and deletion events in directories.
Basic Principles
WatchServiceUse the file system notification mechanism provided by the operating system:
-
Windows: Using ReadDirectoryChangesW
-
Linux: Using inotify
-
Mac OS X: Using FSEvents
WatchService and timed task polling are two different file monitoring strategies that differ significantly in resource consumption.
Resource consumption comparison
| characteristic | WatchService | Timing task polling |
|---|---|---|
| Working mechanism | Operating system event notification | Regularly proactively scan file systems |
| CPU usage | Low (event-driven, almost no CPU consumption when idle) | High (CPU calculation is required for each scan) |
| Memory usage | Medium (maintain event queue and status) | Depends on the scan range and frequency |
| I/O operation | Very rarely (triggered only when there is a change) | High (requires read file system every scan) |
| Response delay | Near real-time (millisecond level) | Depends on polling interval (seconds or longer) |
| Scalability | OK (can monitor a large number of files) | Poor (significant performance degradation in large amounts of files) |
Implement the code directly:
import .*;
import static .*;
/*
Monitor the creation, deletion and modification of files in specified directories
*/
public class DirectoryWatcher {
public static void main(String[] args) throws Exception {
// 1. Create a WatchService instance WatchService watcher = ().newWatchService();
// 2. Register the directory to be monitored Path dir = ("D:/2"); // Replace with the directory you want to monitor WatchKey key = (watcher,
ENTRY_CREATE,
ENTRY_DELETE,
ENTRY_MODIFY);
("Start monitoring: " + dir);
// 3. Event processing loop while (true) {
// Wait and get the next WatchKey key = ();
// Handle all events for (WatchEvent<?> event : ()) {
<?> kind = ();
// Handle OVERFLOW events (events that may be lost or discarded) if (kind == OVERFLOW) {
continue;
}
// Get the event context (usually the file name) WatchEvent<Path> ev = (WatchEvent<Path>) event;
Path filename = ();
("Event Type: %s, File: %s%n", (), filename);
// Custom business processing logic can be added here if (kind == ENTRY_CREATE) {
("New file creation: " + filename);
} else if (kind == ENTRY_DELETE) {
("File Delete: " + filename);
} else if (kind == ENTRY_MODIFY) {
("File Modification: " + filename);
}
}
// 4. Reset WatchKey to continue receiving events boolean valid = ();
if (!valid) {
("WatchKey is no longer valid");
break;
}
}
}
}
Operation effect:
Start monitoring: D:\2
Event type: ENTRY_DELETE, file: _2025-03-17_13-26-32
File Deletion: _2025-03-17_13-26-32
Event type: ENTRY_CREATE, File: Create a new text document.txt
New file creation: Create a new text document.txt
Event type: ENTRY_DELETE, File: Create a new text document.txt
File Delete: Create a new text document.txt
Event type: ENTRY_CREATE, file:
New file creation:
import .*;
import static .*;
/*
Monitor the creation, deletion and modification of files in specified directories
*/
import .*;
import static .*;
import ;
/*
Monitor the creation, deletion and modification of files in specified directories (including subfolders)
*/
public class RecursiveDirectoryWatcher {
private final WatchService watcher;
private final Path rootDir;
public RecursiveDirectoryWatcher(Path dir) throws IOException {
= ().newWatchService();
= dir;
//Recursively register all subdirectories registerAllSubdirectories(dir);
}
private void registerAllSubdirectories(final Path start) throws IOException {
(start)
.filter(Files::isDirectory)
.forEach(subDir -> {
try {
("Register monitoring directory: " + subDir);
(watcher, ENTRY_CREATE, ENTRY_DELETE, ENTRY_MODIFY);
} catch (IOException e) {
("Cannot register directory" + subDir + ": " + e);
}
});
}
public void startWatching() {
("Start monitoring the directory tree: " + rootDir);
while (true) {
WatchKey key;
try {
key = ();
} catch (InterruptedException e) {
("Monitoring is interrupted");
return;
}
for (WatchEvent<?> event : ()) {
<?> kind = ();
if (kind == OVERFLOW) {
continue;
}
@SuppressWarnings("unchecked")
WatchEvent<Path> ev = (WatchEvent<Path>) event;
Path filename = ();
Path dir = (Path) ();
Path fullPath = (filename);
("Event Type: %s, File: %s%n", (), fullPath);
// If it is a new directory, register monitoring if (kind == ENTRY_CREATE && (fullPath)) {
try {
registerAllSubdirectories(fullPath);
} catch (IOException e) {
("Cannot register a new directory" + fullPath + ": " + e);
}
}
}
if (!()) {
("WatchKey is no longer valid");
break;
}
}
}
public static void main(String[] args) throws IOException {
Path dir = ("D:/2"); // Replace with the directory you want to monitor new RecursiveDirectoryWatcher(dir).startWatching();
}
}
import .*;
import static .*;
import ;
/*
Monitor the creation, deletion and modification of files in specified directory (specified type files)
*/
public class TxtFileWatcher {
private final WatchService watcher;
private final Path dir;
public TxtFileWatcher(Path dir) throws IOException {
= ().newWatchService();
= dir;
// Register the monitoring directory (watcher, ENTRY_CREATE, ENTRY_DELETE, ENTRY_MODIFY);
}
public void startWatching() {
("Start monitor .txt file changes, directory: " + dir);
while (true) {
WatchKey key;
try {
key = ();
} catch (InterruptedException e) {
("Monitoring is interrupted");
return;
}
for (WatchEvent<?> event : ()) {
<?> kind = ();
if (kind == OVERFLOW) {
continue;
}
@SuppressWarnings("unchecked")
WatchEvent<Path> ev = (WatchEvent<Path>) event;
Path filename = ();
// Only process .txt files if (().endsWith(".txt")) {
Path fullPath = (filename);
("Event Type: %s, File: %s%n", (), fullPath);
// Here you can add specific processing logic for .txt files if (kind == ENTRY_CREATE) {
("New .txt file creation: " + fullPath);
} else if (kind == ENTRY_MODIFY) {
("txt file was modified: " + fullPath);
// You can read file contents and other operations here } else if (kind == ENTRY_DELETE) {
("txt file was deleted: " + fullPath);
}
}
}
if (!()) {
("WatchKey is no longer valid");
break;
}
}
}
public static void main(String[] args) throws IOException {
Path dir = ("D:/2"); // Replace with the directory you want to monitor new TxtFileWatcher(dir).startWatching();
}
}