如何实现多个线程安全的读/写锁（ConcurrentHashmap）

Question

I have an application which reads and writes a number of files. The aim is to prevent a specific file from being read or written while it is being written by another thread. I do not want to lock the reading and writing of all files while a single file is being written as this causes unnecessary locking.

To try and achieve this I am using a concurrentHashMap in conjunction with a synchonized block, but if there is a better solution I am open to it.

Here is the rough code.

private static final ConcurrentMap<String, String> lockMap = new ConcurrentHashMap();


private void createCache(String templatePath, String cachePath){

//get template 
String temp = getTemplate(templatePath);

String myRand = randomString();
lockMap.put(cachePath,myRand);

// save cache file
  try {
    // ** is  lockMap.get(cachePath) still threadsafe if another thread has changed the row's value?
    synchronized ( lockMap.get(cachePath) ){
      Files.write(Paths.get(cachePath),temp.getBytes(StandardCharsets.UTF_8));
    }
  } finally {
    // remove lock if not locked by another thread in the meantime
    lockMap.remove(cachePath, myRand);
  }

}


private String getCache(String cachePath){

 String output = null;

  //only lock if this specific file is being written at the moment
  if ( lockMap.contains(cachePath) ){
        synchronized ( lockMap.get(cachePath) ){
            output = getFile(cachePath);
        }
    } else {
        output = getFile(cachePath);
    }

  return output;

}

// main event        
private String cacheToString (String templatePath, String cachePath){

  File cache = new File(cachePath);

  if ( !cache.exists() ){
    createCache(templatePath, cachePath)
  }

  return getCache(cachePath);

}

The problem I have is that although the thread will only remove the lock for the requested file if it's unchanged by another thread, it's still possible for another thread to update the value in the lockMap for this entry - if this happens will the synchronisation fail?

Answer 1

I would write a new temporary file each time and rename it when finished. Renaming is atomic.

// a unique counter across restarts
final AtomicLong counter = new AtomicLong(System.currentTimeMillis()*1000);

private void createCache(String templatePath, String cachePath) {
    //get template
    String temp = getTemplate(templatePath);

    Path path = Paths.get(cachePath);
    Path tmpPath = Paths.get(path.getParent().toString(), counter.getAndIncrement() + ".tmp");
    // save cache file
    Files.write(tmpPath, temp.getBytes(StandardCharsets.UTF_8));
    Files.move(tmpPath, path, ATOMIC_MOVE, REPLACE_EXISTING);
}

If multiple threads try to write to the same file, the last one to perform a move wins.