Directory watch, locked files

Question

I´m try to build a application which, by threads, are listening to directory for changes. Everything works fine, but there is a little bug. I´m very new to the whole threads-thing... So, this problem probably based on my ignorance...

The program can se all the changes in the picked directory, BUT, when the threads are running, i cant modify the files inside the directory... Those are locked in the process...

I will be very happy if someone perhaps can give me some tips in how i can solve this.

Thank you in advance

DirWatch

 public class DirWatch implements Runnable{
    Path dirPath;
    private boolean run = true;
    private boolean created = false;
    private boolean modified = false;
    private boolean compressed = false;
    private boolean isJSON = false;

    /**
 *
 * @param path
 * @throws IOException
 */
public void setWatchPath(String path) throws IOException {
    dirPath = Paths.get(path);

    try {
        Boolean isFolder = (Boolean) Files.getAttribute(dirPath, "basic:isDirectory", new LinkOption[]{NOFOLLOW_LINKS});
        if (!isFolder) {
            throw new IllegalArgumentException("Path: " + dirPath + " is not a folder");
        }
    } catch (IOException ioe) {
        ioe.printStackTrace();
    }

    System.out.println("Watching path: " + path);


}

public void setDirPathWatchRun(boolean run){
    this.run = run;
}

public boolean isCreated() {
    return created;
}

public void setCreated(boolean created) {
    this.created = created;
}

public boolean isModified() {
    return modified;
}

public void setModified(boolean modified) {
    this.modified = modified;
}

public boolean isCompressed() {
    return compressed;
}

public void setCompressed(boolean compressed) {
    this.compressed = compressed;
}

public boolean isJSON() {
    return isJSON;
}

public void setJSON(boolean JSON) {
    isJSON = JSON;
}

private void checkFileType(String fileName){
    String extension = fileName.substring(fileName.length() - 4);
    if(extension.equalsIgnoreCase(FILE_TYPE.TAR.getFileType())){
        setCompressed(true);
        System.out.println(extension);
    }
    if(extension.equalsIgnoreCase(".json")){
        setJSON(true);
    }
}

@Override
public void run() {
    FileSystem fs = dirPath.getFileSystem ();
    try(WatchService service = fs.newWatchService()) {
        dirPath.register(service, ENTRY_CREATE,  ENTRY_DELETE, ENTRY_MODIFY);

        WatchKey key = null;

        while(run) {
            key = service.take();

            WatchEvent.Kind<?> kind = null;
            for(WatchEvent<?> watchEvent : key.pollEvents()) {
                kind = watchEvent.kind();
                if (OVERFLOW == kind) {
                    System.out.println("OVERFLOW");
                    continue;
                } else if (ENTRY_CREATE == kind) {
                    System.out.println("New path created: " + watchEvent.context().toString());
                    setCreated(true);
                    checkFileType(watchEvent.context().toString());
                } else if (ENTRY_DELETE == kind){
                    System.out.println("Path deleted: " + watchEvent.context().toString());
                    setModified(true);
                    checkFileType(watchEvent.context().toString());
                } else if (ENTRY_MODIFY == kind) {
                    System.out.println("Path modified: " + watchEvent.context().toString());
                    setModified(true);
                    checkFileType(watchEvent.context().toString());
                }
            }
            if(!key.reset()) {
                break;
            }
        }
    } catch (InterruptedException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }
}
}

Method Watch in another class

private void watch() throws IOException {
    watchJSON = new DirWatch();
    watchTAR = new DirWatch();
    watchTAR.setWatchPath(serverArgs.getCompressedPath());
    watchJSON.setWatchPath(serverArgs.getExtractedPath());


    Runnable checkSourceActions = new Runnable() {
        @Override
        public void run() {

            while(true) {
                if (watchJSON.isCreated() || (watchJSON.isModified())) {
                    server();
                }

                if(watchTAR.isCreated() || (watchTAR.isModified())) {
                    extractFiles(fileHandler);
                    createManifest(fileHandler);
                    server();
                }

                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    };

    Thread thread1 = new Thread(watchJSON);            
    Thread thread3 = new Thread(watchTAR);            
    Thread thread2 = new Thread(checkSourceActions);
    thread1.start();
    thread2.start();
    thread3.start();
}

When I try to change the file while the program is running