文件線程同步

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();
}

而是在這里可以找到對讀寫鎖類的描述。

從實現的角度來看，您可以創建兩個同步方法之一的實例，並使您的讀/寫線程實例保留對它的引用作為實例變量。