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，而要避免的情况是线程之间的同步方法。有更多选择，但最适合您的情况的是mutex和read-write lock。

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

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

我不是Java专家，但是可以使用Java中的this answer 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();
}

代替here，您可以找到对读写锁类的描述。

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

文件线程同步

2 个答案: