Lesen einer Textdatei nach dem iterativen Aktualisieren ohne das Programm zu stoppen

Question

Ich lese eine Textdatei in meinem Programm und mache einige Änderungen in der Datei und dann ohne das Programm zu stoppen, lese ich die Datei und immer wieder und jedes Zeit sollte ich in der Lage sein, die neueste Version der Datei zu lesen. nach der ersten Änderung in der Datei, andere Male bekomme ich immer noch diese Version der Datei und scheint, dass andere Änderungen nicht angewendet werden. Hier ist, wie ich die Datei lesen:

public static Map<String, Float> readOwnersBiasFile() throws IOException { 
FileInputStream file = new FileInputStream("ownersBias.txt"); 
Map<String, Float> ownerBiasMap = new HashMap<String, Float>(); 
//Construct BufferedReader from InputStreamReader 
BufferedReader br = new BufferedReader(new InputStreamReader(file)); 

    String line = null; 
    while ((line = br.readLine()) != null) { 
     String[] var = line.split("\\^"); 
     ownerBiasMap.put(var[0], Float.valueOf(var[1])); 
    } 

    br.close(); 
    return ownerBiasMap; 

} und hier ist, wie ich meine Änderungen speichern:

public static void storeOwnersUtilityMap(Map<String, Float> ownersUtilityMap) throws IOException { 
    FileInputStream fileInputStream = null; 
    InputStreamReader inputStreamReader = null; 
    BufferedReader bufferedReader = null; 
    List<String> lines = new ArrayList<String>(); 
    try { 
     fileInputStream = new FileInputStream("ownersBias.txt"); 
     inputStreamReader = new InputStreamReader(fileInputStream, "UTF-8"); 
     bufferedReader = new BufferedReader(inputStreamReader); 

     String s; 

     String[] var; 
     if (bufferedReader.readLine() == null) { 
      for (Map.Entry<String, Float> entry : ownersUtilityMap.entrySet()) { 
       lines.add(entry.getKey().concat("^").concat(String.valueOf(entry.getValue()))); 
      } 
     } else 
      while ((s = bufferedReader.readLine()) != null) { 

       var = s.split("\\^"); 
       if (ownersUtilityMap.containsKey(var[0])) 
        s = var[0].concat("^").concat(String.valueOf(ownersUtilityMap.get(var[0]))); 
       lines.add(s); 
      } 

    } catch (FileNotFoundException e) { 
     e.printStackTrace(); 
    } catch (UnsupportedEncodingException e) { 
     e.printStackTrace(); 
    } catch (IOException e) { 
     e.printStackTrace(); 
    } finally { 
     IOUtils.closeQuietly(bufferedReader); 
     IOUtils.closeQuietly(inputStreamReader); 
     IOUtils.closeQuietly(fileInputStream); 
    } 

    fileWriter(lines, "ownersBias.txt"); 

}

private static void fileWriter(List<String> list, String fileName) throws IOException { 
    File fout = new File(fileName); 
    FileOutputStream fos = new FileOutputStream(fout); 

    BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(fos)); 
    Iterator<String> iterator = list.iterator(); 
    while (iterator.hasNext()) { 
     bw.write(iterator.next()); 
     bw.newLine(); 
    } 

    bw.close(); 
} 

Und in meinem Haupt-Methode Ich habe ein Schleife, die einige Sachen zusammen mit dem Lesen und der Änderung der Textdatei tut.

public static void main(String[] args) throws IOException, TasteException { 
for(int i=0;i<10;i++){ 
map= readOwnersBiasFile(); 
do some stuff; 
storeOwnersUtilityMap(map); 
} 
} 

Answer 1

sollte nicht notwendig sein, die Programme zwischen neu einliest zu schließen, ich habe geschrieben Programme, die die gleiche Datei lesen würde und alle externen Änderungen erhalten. Dieser Teil, den ich kenne, funktioniert.

Jetzt scheint die oberste Methode readOwnersBiasFile() nicht alles explizit zu schließen; Ich sehe den BufferedReader geschlossen, aber nicht den InputStreamReader oder FileInputStream. Beim Verlassen der Methode haben die Objekte keine Referenzen und daher sollte die Speicherbereinigung sie finden, das Timing könnte ein Problem sein. Ich empfehle Try-with-Resources für alles Closeable.

Das Betriebssystem kann jedoch Unterschiede verursachen, insbesondere, wenn Sie von derselben JVM schreiben und lesen. In Windows können Sie beispielsweise eine bereits geöffnete Datei nicht löschen/verschieben/umbenennen, aber * nix können Sie. Was ich nicht weiß (teilweise weil ich nicht weiß, dass du eine Runtime-Plattform bist), ist, ob die JVM mit Datei-Handles trickreich ist und versucht, sie so wiederzuverwenden, dass die Änderungen nicht vor dem Schreiben gelöscht werden gelesen werden oder was auch immer.

Wenn es sich lohnt, die Eigenschaften Ihres Dateiobjekts zu untersuchen, stellen Sie sicher, dass Sie Änderungen an der Größe oder am letzten Änderungsdatum sehen oder was auch immer darauf hindeutet, dass Sie tatsächlich die Unterschiede erkennen.

Ich kann auch nichts über die Reihenfolge, die Sie Dinge nennen (insbesondere die ersten beiden Blöcke des Codes), ob Sie Dinge Multithread oder was tun. Öffnen/Lesen/Schreiben in einer Multithread-Umgebung könnte problematisch sein