文件线程同步

Question

如何通过使用线程同步执行读取和写入操作。

条件：如果存在一个文件，写入者可以在其中写入信息，则一次只能写入一个写入者。 如果读者尝试的阅读方式与作者撰写的方式相同，则可能会造成混乱。 由于读者仅查看数据，而不修改数据，因此我们可以允许多个读者同时阅读。

//reader thread
    class Read extends Thread {
        static File Reader fr1 = null;
        static Buffered Reader br1 = null;

        static synchronized void reader() throws IO Exception {

            String path ="C:/Users/teja/Documents/file1.txt";

            fr1 = new File Reader(path);
            br1 = new Buffered Reader(fr);
            int i;
            while ((i = br. read()) != -1)
                System .out. print((char) i);
            System .out. print ln();
        }

        public void run() {
            try {
                reader();
            } catch (IO Exception e) {
                e. print Stack Trace();
            }
        }
    }
    //writer code
    class Writer extends Thread {
        static Buffered Writer bw1 = null;
        static File Writer fw1 = null;

        static synchronized void writer() throws IO Exception {
            Scanner scanner = new Scanner(System.in);
            System .out .print ln("enter data to be added:");
            String data = scanner. nextLine();

            String path = "C:/Users/vt/Documents/file1.txt";
            fw1 = new File Writer(path, true);

            bw1 = new Buffered Writer(fw1);
            bw1.newLine();
            bw1.write(data);
            bw1.flush();

            scanner. close();
            System. out . println("data added");
        }

        public void run() {
            try {
                writer();
            } catch (IO Exception e) {
                e. print Stack Trace();
            }
        }
    }
    //main method
    public class File Read Write {

        public static void main(String[] args) {
           Read rd1 =new Read();
           Read rd2=new Read();
           Writer wt1=new Writer();

           rd1.run();
           rd2.run();
           wt1.run();
           rd1. run();
            }           
    }

我是Java文件和线程的新手。 我知道这不是正确的方法。 引导我。

如果存在一个写入者可以向其中写入信息的文件，则一次只能写入一个写入者。 如果读者尝试的阅读方式与作者撰写的方式相同，则可能会造成混乱。 由于读者仅查看数据，而不修改数据，因此我们可以允许多个读者同时阅读。

Answer 1

有两种方法。

（1）要么锁定资源，要么让读者等待，直到作家完成写操作为止（或者，同样，让作家等待，直到所有读者都完成了）。 这种方法保证了一致性，但是如果许多作家/读者同时在资源上工作，则可能会很慢（请参见java.util.concurrent.locks包中的Lock）。

（2）保留仅提供给读者的文件内容的内存版本。 进行更改后，此内存版本将更新。 在这里，您将获得更快的速度，但是会失去一致性，并且需要更多的内存。

Answer 2

您要避免的条件通常称为race condition而要避免的race condition是线程之间的同步方法。 有更多选择，但最适合您的情况是mutex和read-write lock 。

mutex基本上只是在对共享资源执行任何操作之前锁定资源，而不受操作类型的影响，并在操作终止后释放资源。 因此，一个read会阻塞资源和任何其他操作， read或write将被阻止。 write也会阻塞资源，因此在操作终止和mutex解锁之前，无法再执行其他read或write操作。 因此， mutex基本上具有两种状态：锁定和解锁。

基于只读操作不会导致不一致的事实， read-write lock为您提供了更大的自由度。 read-write lock具有3种状态：解锁，读取锁，写入锁。 写锁用作阻止任何其他操作的常规互斥锁。 相反，读锁定仅阻止写操作。

我不是Java专家，但是根据此答案 ，Java中的mutex可以用作以下内容：

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

private final Lock lock = new ReentrantLock(true);
lock.lock()
/*open file and do stuff*/
try {
  // do something
} catch (Exception e) {
  // handle the exception
} finally {
  lock.unlock();
}

而是在这里可以找到对读写锁类的描述。

从实现的角度来看，您可以创建两个同步方法之一的实例，并使您的读/写线程实例保留对它的引用作为实例变量。