只允许访问一个对象来读取文件并进行编写

Question

I would like to know if multiple threads try to access a single txt file, how to restrict it? If thread A tries to access the file till it completes the reading and writing part, other threads must wait. Here is what I tried.

package singleton;

/**
 *
 * @author Admin
 */
import java.io.*;
class ReadFileUsingThread
{
    public synchronized void readFromFile(final String f, Thread thread) {

    Runnable readRun = new Runnable() {
      public void run() {
        FileInputStream in=null;
        FileOutputStream out=null;
        String text = null;
        try{
          Thread.sleep(5000);
          File inputFile = new File(f);
          in = new FileInputStream(inputFile);
          byte bt[] =  new byte[(int)inputFile.length()];
          in.read(bt);
          text = new String(bt);
          //String file_name = "E:/sumi.txt";
          //File file = new File(file_name);
         // FileWriter fstream = new FileWriter("E:/sumi.txt");
          out = new FileOutputStream("E:/sumi.txt");
          out.write(bt);
          System.out.println(text);


       } catch(Exception ex) {
       }  
      }
    };
    thread = new Thread(readRun);
    thread.start();
  }

    public static void main(String[] args) 
    {
        ReadFileUsingThread files=new ReadFileUsingThread();
        Thread thread1=new Thread();
        Thread thread2=new Thread();
        Thread thread3=new Thread();

        String f1="C:/Users/Admin/Documents/links.txt";//,f2="C:/employee.txt",f3="C:/hello.txt";
        thread1.start();
        files.readFromFile(f1,thread1);
        thread2.start();
        files.readFromFile(f1,thread2);
        thread3.start();
        files.readFromFile(f1,thread3);
    }
}

Answer 1

An interesting way to do it would be to intern the string value of the file's FQN, and then synchronize on it. The more 'traditional' way is to use the FileChannel object and lock on it, with other processes simply waiting on the lock, to take their turns.

Caveat : None of these solutions will solve contention between JVM's, or contention between a JVM and other external programs.

Answer 2

You can use a ReentrantReadWriteLock .

ReadWriteLock lock = new ReentrantReadWriteLock();

...

lock.readLock().lock();
try {
  //do reading stuff in here
} finally {
   lock.readLock().unlock();
}

...

lock.writeLock().lock();
try {
  //do writing stuff in here
} finally {
  lock.writeLock().unlock();
}

Or, for something simpler, you could synchronize on the interned (interning ensures that the String object is shared) String object that represents that File 's full path name:

synchronized(file.getAbsolutePath().intern()) {
   //do operations on that file here
}

The ReadWriteLock approach will have better performance as Thread s will be allowed to read the file at the same time while manually synchronizing does not allow this.