Programma Due Thread File

[7marco7zz]

Ciao a tutti. Ho un problema con un programma.
Ci sono 2 thread, e un file che rimane aperto.
Il primo thread scrive una linea di testo sul file, mentre il secondo thread le legge una ad una appena viene scritta ma non va mai in fase di sleep.
Quindi:
-Il file viene aperto
-il primo thread scrive la linea su file
-Il secondo legge la linea appena viene scritta e non va mai in sleep.
-e così via fino alla chiusura del file
Ringrazio anticipatamente chi riesca a risolvere il problema.
( pensavo di usare il comando endoffile() per controllare se il primo thread ha scritto una nuova linea, però son in alto mare)

[antotan]

Puoi utilizzare questa come base, però devi lavorarci sopra:

import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class Main
{
   public static void main(String[] args) throws InterruptedException
   {
      File file = new File("log.txt");
      Thread w = new Thread(new Writer(file));
      Thread r = new Thread(new Reader(file));
      
      w.start();
      r.start();
      
      w.join();
      r.join();      
   }
}

class Writer implements Runnable
{    
   private File _file;
   
   public Writer(File file)
   {
      _file = file;
   }
   
   public void run()
   {            
      try
      {                  
         for(int i = 0; i < 100; i++)
         {
            Thread.sleep(5000);
            String line = "Line_" + String.valueOf(i);
            System.out.println("[T1] Writing " + line + "...");
            FileWriter fw = new FileWriter(_file, true);
            fw.write(line + "\n");            
            fw.flush();
            fw.close();            
         }
      }
      catch (IOException e)
      {
         e.printStackTrace();
      }
      catch (InterruptedException e)
      {
         e.printStackTrace();
      }      
   }
}

class Reader implements Runnable
{      
   private File _file;
   private long _lastMod;
   private long _toSkip = 0;
   
   public Reader(File file)
   {
      _file = file;
      if(_file.exists())
      {
         _lastMod = _file.lastModified();         
      }
      else
      {
         _lastMod = -1;
      }
   }       
   
   public void run()
   {
      try
      {
         while(true)
         {                 
            if(_file.exists())
            {
               long lastMod = _file.lastModified();
               if(lastMod != _lastMod)
               {
                  System.out.println("[T2] Change detected");
                  FileReader r = new FileReader(_file);
                  r.skip(_toSkip);
                  
                  char[] buff = new char[1024];
                  int n = -1;
                  while( (n = r.read(buff)) != -1)
                  {
                     System.out.print("[T2] " + new String(buff, 0, n) );
                     _toSkip += n;
                  }               
                  
                  r.close();
                  
                  _lastMod = lastMod;
               }
            }
         }
      }
      catch(IOException ex)
      {
         ex.printStackTrace();
      }
   }
} 

Il primo thread "tocca" e scrive su file. Il secondo controlla la data di ultima modifica, skippa i caratteri già letti e legge fino alla fine del file.

[LeleFT]

@7marco7zz: se hai un problema, sei tu che devi postare il codice e specificare qual è il problema.

Da quello che si capisce della tua discussione, stai cercando qualcuno che svolga per te l'esercizio e questo non è ammesso come da Regolamento interno.

Questo tipo di quesiti vanno posti nel forum "Offro Lavoro / Collaborazione".

Qualcuno ti ha già dato un aiuto molto grosso, spendilo bene.

Questa discussione viene chiusa da regolamento.


Ciao.