Может ли переменная быть изменчивой?

Question

У меня есть класс, в котором есть переменная boolean, называемая isbeingwritten. Он отслеживает, записывается ли файл. Функция этого класса вызывает несколько потоков, которые записываются в файлы. они сначала проверит значение переменной isbeingwritten, и если это false, установите ее на true и начните писать, иначе они будут ждать. По окончании записи они изменят значение на false. Должна ли эта переменная быть сделана volatile?

class A 
{ 
    public boolean isbeingwrittenfalse; 
    public void func() 
    { 
     new thread1(); 
     new thread2(); 
    } 
    class thread1 implements Runnable 
    { 
     Thread t; 
     thread1() 
     { 
      t=new Thread (this); 
      t.start(); 
     } 
     public void run() 
     { 
      while(isbeingwritten); 
      isbeingwritten=true; 
      //wrrite very long string 
      isbeingwritten=false; 
     } 
    } 
    class thread2 implements Runnable 
    { 
     Thread t; 
     thread2() 
     { 
      t=new Thread (this); 
      t.start(); 
     } 
     public void run() 
     { 
      while(isbeingwritten); 
      isbeingwritten=true; 
      //wrrite very long string 
      isbeingwritten=false; 
     } 
    } 

Ниже правильное решение

public class XSSThread implements Runnable { 
    Thread xt; 

    public void init() { 
     xt = new Thread(this); 
     xt.start(); 
    } 

    public void run() { 
     new Thread1().init(); 
     new Thread2().init(); 
    } 

    public synchronized void saveToFile(String a) { 
     File aFile = new File("filename.txt"); 
     try { 
      BufferedWriter out = new BufferedWriter(new FileWriter(aFile, aFile.exists())); 
      out.write(a + "\r\n"); 
      out.close(); 
     } catch (IOException e) { 
      e.printStackTrace(); 
     } 
    } 
} 

public class Thread1 extends XSSThread implements Runnable{ 
    Thread xt1; 

    public void init() { 
     xt1 = new Thread(this); 
     xt1.start(); 
    } 

    public void run() { 
     String a;//very long string 
     saveToFile(a); 
    } 
} 

public class Thread2 extends XSSThread implements Runnable { 
    Thread xt2; 

    public void init() { 
     xt2 = new Thread(this); 
     xt2.start(); 
    } 

    public void run() { 
     String a;//very long string 
     saveToFile(a); 
    } 
} 

Answer 1

Нет, это не правильно, потому что оба потока могут видеть isbeingwritten == false перед тем как обновить поле для true. Ни volatile, ни AtomicBoolean решить эту проблему. Вы должны использовать надлежащие механизмы синхронизации:

private Object writeLock = new Object(); 
class thread1 implements Runnable{ 
    public void run(){ 
     synchronized (writeLock) { 
      //write very long text 
     } 
    } 
} 
class thread2 implements Runnable{ 
    public void run(){ 
     synchronized (writeLock) { 
      //write very long text 
     } 
    } 
} 

Answer 2

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

Модификатор volatile сообщает JVM, что поток, обращающийся к переменной, должен всегда согласовывать свою собственную частную копию переменной с основной копией в памяти .

Неустойчивые переменные совместно используют функции видимости synchronized Ключевые слова oj java. Это означает, что потоки автоматически видят самое последнее значение для переменных переменных.

Вы можете использовать его как the.se

public class FileReadingWritingTask extends Thread { 

    private volatile boolean isbeingwritten; 

    public void run() { 
     if (!isbeingwritten) { 
      isbeingwritten = true; 
      // do some stuff... 

      // stuff ends 
      tellMeToStop(); 

     } 
    } 

    public void tellMeToStop() { 
     isbeingwritten = false; 
    } 
}