JPathwatch

 public class JPathwatchSample {
 
   public static void main(String[] args) throws Exception {
     WatchService watchService = FileSystems.getDefault().newWatchService();
     Path watchedPath = Paths.get("c:/temp");
     WatchEvent.Kind[] eventsToWatch = new WatchEvent.Kind[] {
         StandardWatchEventKind.ENTRY_CREATE,
         StandardWatchEventKind.ENTRY_DELETE,
         StandardWatchEventKind.ENTRY_MODIFY,
        StandardWatchEventKind.OVERFLOW,
        ExtendedWatchEventKind.ENTRY_RENAME_FROM,
        ExtendedWatchEventKind.ENTRY_RENAME_TO,
    };
    WatchKey key = null;
    try {
      key = watchedPath.register(watchService, eventsToWatch, ExtendedWatchEventModifier.FILE_TREE);
    }
    catch (UnsupportedOperationException uox) {
      System.err.println("file watching not supported!");
    }
    catch (IOException iox) {
      System.err.println("I/O errors");
    }

    for (;;) {
      // take() will block until a file has been created/deleted
      WatchKey signalledKey;
      try {
        signalledKey = watchService.take();
      }
      catch (InterruptedException ix) {
        continue;
      }
      catch (ClosedWatchServiceException cwse) {
        System.out.println("watch service closed, terminating.");
        break;
      }

      // get list of events from key
      List<WatchEvent> list = signalledKey.pollEvents();

      // VERY IMPORTANT! call reset() AFTER pollEvents() to allow the
      // key to be reported again by the watch service
      signalledKey.reset();

      System.out.println("--------------------------------");
      // we'll simply print what has happened; real applications
      // will do something more sensible here
      for (WatchEvent e : list) {
        String message = "";
        if (e.kind() == StandardWatchEventKind.ENTRY_CREATE) {
          Path context = (Path) e.context();
          message = context.toString() + " created";
        }
        else if (e.kind() == StandardWatchEventKind.ENTRY_DELETE) {
          Path context = (Path) e.context();
          message = context.toString() + " deleted";
        }
        else if (e.kind() == StandardWatchEventKind.ENTRY_MODIFY) {
          Path context = (Path) e.context();
          message = context.toString() + " modified";
        }
        else if (e.kind() == ExtendedWatchEventKind.ENTRY_RENAME_FROM) {
          Path context = (Path) e.context();
          message = context.toString() + " renamed from";
        }
        else if (e.kind() == ExtendedWatchEventKind.ENTRY_RENAME_TO) {
          Path context = (Path) e.context();
          message = context.toString() + " renamed to";
        }
        else if (e.kind() == StandardWatchEventKind.OVERFLOW) {
          message = "OVERFLOW: more changes happened than we could retreive";
        }
        System.out.println(message);
      }
    }
  }
}

 public interface IWorkerSemafor {
   public void working();
   public void notWorking();
 }
 
 class BatchExecutor implements Runnable {
   private final IWorkerSemafor semafor;
 
   BatchExecutor(IWorkerSemafor semafor) {
    this.semafor = semafor;
  }

  @Override
  public void run() {
    this.semafor.working();
    try {
      Thread.sleep(1 * 1000); // 1 sec
    }
    catch (InterruptedException e) {
      return;
    }
    finally {
      this.semafor.notWorking();
    }
    try {
      System.out.println("executing command... "+new Date());
      Runtime.getRuntime().exec("cmd /c build.bat ");
    }
    catch (IOException e) {
      e.printStackTrace();
    }
  }
}

 public class JPathwatchSample2 {
 
   public static void main(String[] args) throws Exception {
     Thread watcherT = new Thread(watcher);
     watcherT.start();
     System.out.println("JPathwatch: Press CTR+C to stop");
     for (;;) {
       Thread.sleep(1000);
     }
  }

  static volatile boolean workerRunning = false;

  static Runnable watcher = new BackgroundWatcher();

  static class BackgroundWatcher implements Runnable, IWorkerSemafor {
    public void run() {
      WatchService watchService = FileSystems.getDefault().newWatchService();
      Path watchedPath = Paths.get("c:/temp");
      setup(watchService, watchedPath);
      for (;;) {
        WatchKey signalledKey;
        try {
          signalledKey = watchService.take();
        }
        catch (InterruptedException ix) {
          continue;
        }
        catch (ClosedWatchServiceException cwse) {
          System.out.println("watch service closed, pls exit");
          break;
        }
        List<WatchEvent<?>> list = signalledKey.pollEvents();
        signalledKey.reset();
        if (workerRunning) {
          continue;
        }
        if (null == list || 0 == list.size()) {
          continue;
        }
        Thread worker = new Thread(new BatchExecutor(this));
        worker.start();
      }
    }
    private void setup(WatchService watchService, Path watchedPath) {
      WatchEvent.Kind<?>[] eventsToWatch = new WatchEvent.Kind[] {
          StandardWatchEventKind.ENTRY_CREATE,
          StandardWatchEventKind.ENTRY_DELETE,
          StandardWatchEventKind.ENTRY_MODIFY,
          StandardWatchEventKind.OVERFLOW,
          ExtendedWatchEventKind.ENTRY_RENAME_FROM,
          ExtendedWatchEventKind.ENTRY_RENAME_TO,
      };
      WatchKey key = null;
      try {
        key = watchedPath.register(watchService, eventsToWatch, ExtendedWatchEventModifier.FILE_TREE);
      }
      catch (UnsupportedOperationException uox) {
        uox.printStackTrace();
      }
      catch (IOException iox) {
        iox.printStackTrace();
      }
    }
    @Override
    public void working() {
      workerRunning = true;
    }
    @Override
    public void notWorking() {
      workerRunning = false;
    }
  };
}