Fils et écriture de fichier

J'ai un programme java qui utilise 20 threads. Chacun d'entre eux d'écrire leurs résultats dans un fichier appelé output.txt.

Je reçois toujours un nombre différent de lignes dans output.txt.

Peut-il être un problème avec la synchronisation des threads? Est-il un moyen de gérer cela?

source d'informationauteur RazorMx

java multithreading

27

peut-il être un problème de synchronisation des threads?

Oui.

Il y a une façon de gérer cela?

Oui, s'assurer que les écritures sont sérialisés par la synchronisation sur un mutex. Ou, à l'inverse, ont seulement un thread que des sorties vers le fichier, et vous disposez de tous les autres threads simplement la file d'attente de texte à être écrit dans une file d'attente que l'un thread d'écriture attire de. (De cette façon, le 20 threads principaux ne pas bloquer sur les I/O.)

Re le mutex: Par exemple, si elles utilisent toutes le même FileWriter exemple (ou autre), que j'appellerai fwils pourraient l'utiliser comme un mutex:
```
synchronized (fw) {
    fw.write(...);
}
```
Si ils sont chacun à l'aide de leurs propres FileWriter ou que ce soit, de trouver quelque chose d'autre, ils ont tous en commun d'être le mutex.

Mais encore une fois, d'avoir un thread qui effectue l'I/O au nom des autres est probablement aussi une bonne façon d'aller.
9

Je vous suggère d'organiser de cette façon: Un thread consommateur de consommer toutes les données et écrire dans le fichier. Tous les threads de travail permettra de produire des données pour le thread consommateur en synchrone. Ou avec plusieurs threads d'écriture de fichier vous pouvez utiliser un mutex ou verrouille implémentations.
2

Si vous voulez un semblant de performance et de facilité de gestion, rendez-vous avec le producteur-consommateur de la file d'attente et qu'un seul fichier-écrivain, comme suggéré par Alex et les autres. Permettre à tous les fils au fichier avec un mutex est juste confus, chaque disque retard est transféré directement dans votre application principale fonctionnalité, (avec ajout d'un conflit). Cela est particulièrement solennelle avec la lenteur des lecteurs réseau qui ont tendance à disparaître sans avertissement.
1

Vous devez utiliser la synchronisation dans ce cas. Imaginez que 2 fils (t1 et t2) ouvrez le fichier dans le même temps, et commencer à écrire. Les modifications apportées par le premier thread sont écrasé par le deuxième thread parce que le deuxième thread est le dernier à enregistrer les modifications dans le fichier. Lorsqu'un thread t1 qui est écrit dans le fichier, t2 doivent attendre jusqu'à ce t1 fin de tâche avant de pouvoir l'ouvrir.

Si vous pouvez tenir votre fichier en tant que FileOutputStream vous pouvez le verrouiller comme ceci:

FileOutputStream file = ...
....
//Thread safe version.
void write(byte[] bytes) {
  try {
    boolean written = false;
    do {
      try {
        //Lock it!
        FileLock lock = file.getChannel().lock();
        try {
          //Write the bytes.
          file.write(bytes);
          written = true;
        } finally {
          //Release the lock.
          lock.release();
        }
      } catch ( OverlappingFileLockException ofle ) {
        try {
          //Wait a bit
          Thread.sleep(0);
        } catch (InterruptedException ex) {
          throw new InterruptedIOException ("Interrupted waiting for a file lock.");
        }
      }
    } while (!written);
  } catch (IOException ex) {
    log.warn("Failed to lock " + fileName, ex);
  }
}

Bien, sans aucun détail de l'implémentation, il est difficile de savoir, mais comme mon cas de test montre, j'ai toujours de 220 lignes de sortie, c'est à dire, un nombre constant de lignes, avec FileWriter. Notez qu'aucune synchronized est utilisé ici.

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
/**
* Working example of synchonous, competitive writing to the same file.
* @author WesternGun
*
*/
public class ThreadCompete implements Runnable {
private FileWriter writer;
private int status;
private int counter;
private boolean stop;
private String name;
public ThreadCompete(String name) {
this.name = name;
status = 0;
stop = false;
//just open the file without appending, to clear content
try {
writer = new FileWriter(new File("test.txt"), true);
} catch (IOException e) {
//TODO Auto-generated catch block
e.printStackTrace();
}
}
public static void main(String[] args) {
for (int i=0; i<20; i++) {
new Thread(new ThreadCompete("Thread" + i)).start();
}
}
private int generateRandom(int range) {
return (int) (Math.random() * range);
}
@Override
public void run() {
while (!stop) {
try {
writer = new FileWriter(new File("test.txt"), true);
if (status == 0) {
writer.write(this.name + ": Begin: " + counter);
writer.write(System.lineSeparator());
status ++;
} else if (status == 1) {
writer.write(this.name + ": Now we have " + counter + " books!");
writer.write(System.lineSeparator());
counter++;
if (counter > 8) {
status = 2;
}
} else if (status == 2) {
writer.write(this.name + ": End. " + counter);
writer.write(System.lineSeparator());
stop = true;
}
writer.flush();
writer.close();
} catch (IOException e) {
//TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}

Que je comprends (et de tester), il y a deux phases dans ce processus:

tous les threads du pool de tous créé et démarré, prêt à saisir le fichier;
l'un d'eux l'attrape, et je suppose que c'ensuite en interne ce qu'il se verrouilleempêche les autres threads pour obtenir l'accès, parce que je ne vois jamais une ligne combinée des matières qui proviennent de deux threads. Alors, quand un thread d'écriture, d'autres sont en attente jusqu'à la fin de la ligne, et très probablement, libère le fichier. Donc, pas de condition de course va se passer.
le plus rapide des autres attrape le fichier et commence à écrire.

Bien, c'est comme une foule qui les attend à l'extérieur d'une salle de bains, sans file d'attente.....

Donc, si votre œuvre est différent, montrer le code et nous pouvons vous aider à le décomposer.

Vous devez vous connecter pour publier un commentaire.