синхронизация файловых потоков

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

Условие, которое вы хотите избежать, обычно называется race condition, а то, чего вы хотите избежать, - это метод синхронизации между потоками. Доступно больше вариантов, но наиболее подходящими для вашего случая являются mutex и read-write lock.

A mutex в основном просто блокирует ресурс перед выполнением любой операции с общим ресурсом, независимо от типа операции, и освобождает его после завершения операции. Таким образом, read заблокирует ресурс и любые другие операции, read или write будут заблокированы. write также заблокирует ресурс, поэтому снова никакие другие операции read или write не могут быть выполнены до того, как действие будет прекращено и mutex разблокировано. Таким образом, у mutex есть 2 состояния: заблокировано и разблокировано.

read-write lock дает вам больше свободы благодаря тому факту, что операции только для чтения не приводят к несоответствиям. A read-write lock имеет 3 состояния: разблокировано, блокировка чтения, блокировка записи. Блокировка записи работает как обычный мьютекс, блокирующий любую другую операцию. Блокировка чтения наоборот блокирует только операции записи.

Я не эксперт по Java, но с этот ответ mutex в Java можно использовать следующим образом:

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

Вместо здесь вы можете найти описание класса блокировки чтения-записи.

С точки зрения реализации вы можете создать экземпляр одного из двух методов синхронизации, и ваши экземпляры потока чтения / записи сохранят ссылку на него как переменную экземпляра.

Answer 2

Есть два подхода к этому.

(1) Либо заблокируйте ресурс, и пусть читатели ждут, пока писатель завершит операцию записи (или аналогично, пусть писатель ждет, пока все читатели не закончат). Этот подход гарантирует согласованность, но может быть медленным, если над ресурсом одновременно работает много писателей / читателей (см. Блокировка в пакете java.util.concurrent.locks).

(2) Хранить в памяти версию содержимого файла, предназначенную только для читателей. После внесения изменений эта версия в памяти обновляется. Здесь у вас будет больше скорости, но вы потеряете последовательность и вам потребуется больше памяти.