Lecture de fichier en multithread

Version imprimable

01/02/2016, 12h11
jeanmidudu

Lecture de fichier en multithread

Bonjour tout le monde,

Je poste rarement dans le forum java, mais j'ai vraiment besoin de votre aide, svp.

J'ai besoin de faire un programme simple en Java, qui prend un fichier texte (.txt) en argument et qui compte le nombre de mots dans ce fichier. Là rien de compliqué.
La difficulté :

Le fichier doit être lu séparément par 5 threads qui se répartissent en parts égales le fichier (le thread 1 comptera les mots des lignes 1 à 1/5 du fichier, le second des lignes 1/5 du fichier +1 à 2/5 et ainsi de suite). Ces 5 threads doivent être exécutés en même temps et lancés par un serveur et doivent tous retourner au serveru le nombre de mots contenus dans leur partie, qui lui en fera la somme.

Voilà la difficulté, si vous pouviez m'aider ce serait vraiment génial, car j'ai de grosses lacunes dans la compréhension de l'utilisation de server et du multithread en java.

Merci d'avance!!
01/02/2016, 16h12
Gugelhupf

Par rapport au problème que tu décris, je ne pense pas que tu aies réellement besoin des threads pour réaliser ton besoin, je veux dire par là que ça n'ira pas "plus vite" de faire 5 choses en même temps. JM Doudoux propose un cours sur les threads ici.

Note: Si tu souhaites faire ça pour t'amuser, fait tout de même attention aux flottants avec tes 1/5.
01/02/2016, 17h13
jeanmidudu

J'en suis parfaitement conscient, utiliser les threads de façon simultanée ne serait utile que pour traiter des fichiers texte très lourds.

Cependant c'est l'exercice le plus simple que j'ai pu trouver, mais dont il n'existe pas de solution. Je me demandais si quelqu'un pouvait m'en fournir une car j'ai de réelles difficultés avec l'utilisation de serveur multithreadé. Et le cours de M. Jean-Michel Doudoux ne m'a rien apporté de plus pour réussir, au contraire cela n'a fait que m'embrouiller encore plus. Ce que je souhaiterais, c'est avoir un exemple simple. Et je trouve l'exercice proposé particulièrement simple et facile à comprendre en ce sens.

Alors svp, quelqu'un aurait la bonté de me proposer une solution? A moins que vous ne préféreriez me proposer des cours particuliers.

Merci d'avance!
01/02/2016, 17h35
joel.drigo

C'est un exercice sur la lecture multi-threadé de fichier que tu cherches, ou un exercice simple sur les threads ? Parce qu'un système producteur/consommateur, ou un buffer tournant, par exemple, est un exercice simple standard de mise en oeuvre des threads, avec possibilité de travailler le synchronised, les wait, les notify, puis les Locks.
01/02/2016, 17h43
Gugelhupf

Citation:

utiliser les threads de façon simultanée ne serait utile que pour traiter des fichiers texte très lourds

Pourquoi penses-tu cela ? Je pense que tu n'as pas compris l'objectif des threads et dans quel contexte on les utilise.

Citation:

Cependant c'est l'exercice le plus simple que j'ai pu trouver

Ce n'est pas l'exemple le plus simple que j'aurais donné pour faciliter ta compréhension, mais rien ne t'empêches de continuer sur ce dernier. Cependant tu parles de "serveur" et on a l'impression que ton besoin est adapté à un environnement web... on évite si possible d'utiliser les threads pour les projets web (surtout si c'est pour lire différents bouts d'un même fichier 5 fois) car non seulement ton client attendra quoi qu'il arrive l'ensemble du temps requis pour lire le résultat final mais en plus de cela créer des threads consomme des ressources (en gros tu vas consommer des ressources inutilement pour ce cas).

Sincèrement le cours de JM Doudoux est pas mal, n'hésite pas à le relire tranquillement.
01/02/2016, 18h41
jeanmidudu

Citation:

Envoyé par Gugelhupf

Pourquoi penses-tu cela ? Je pense que tu n'as pas compris l'objectif des threads et dans quel contexte on les utilise.

Ce n'est pas l'exemple le plus simple que j'aurais donné pour faciliter ta compréhension, mais rien ne t'empêches de continuer sur ce dernier. Cependant tu parles de "serveur" et on a l'impression que ton besoin est adapté à un environnement web... on évite si possible d'utiliser les threads pour les projets web (surtout si c'est pour lire différents bouts d'un même fichier 5 fois) car non seulement ton client attendra quoi qu'il arrive l'ensemble du temps requis pour lire le résultat final mais en plus de cela créer des threads consomme des ressources (en gros tu vas consommer des ressources inutilement pour ce cas).

Sincèrement le cours de JM Doudoux est pas mal, n'hésite pas à le relire tranquillement.

Aucune utilisation web attendue pour ma part, mais le but est ici d'utiliser un "serveur" (programme principal) qui répartirait la tâche aux différents threads. Mon réel problème est, je pense, que je ne comprend pas du tout comment les threads communiquent, et je ne trouve nulle part quelque chose qui l'explique clairement. J'ai remarqué à plusieurs reprise l'utilisation de PRINTWRITER et BUFFEREDREADER mais je n'y comprend rien.
01/02/2016, 19h02
joel.drigo
A mon avis, commence par mettre de côté cette notion de serveur : fait un programme qui prend en paramètre un fichier, point. Ensuite, tu pourras t'occuper de la notion de serveur (probablement offrant un service, restant à définir sous quel protocole), qui n'intervient pas dans le programme en lui-même.
Ensuite, il me semble inutile de chercher à lire un fichier en multi-thread : à moins d'avoir un dispositif physique capable de lire en parallèle des données sur le support physique, effet de cache mis à part, ça a plutôt tendance à tout ralentir. Fais la lecture entière en une fois, en chargeant le fichier dans une liste, par exemple (ou un tableau, peu importe). Ensuite, tu peux répartir le traitement de cette liste (ou tableau) entre n threads.
Ensuite :
- Pour remplir la liste, soit tu utilises la méthode readAllLines de la classe Files qui va tout te charger d'un coup très facilement, soit tu utilises un BufferedReader pour lire le fichier ligne à ligne, que tu ajoutes à une liste au fur et à mesure. C'est du standard et tu trouveras l'exemple pourl le faire dans les FAQ.
- A partir du moment où la liste est entièrement chargée, il n'est pas difficile de la découper en n sous-listes à procurer à n threads.
- La communication entre threads se fait exactement comme pour une communication entre n'importe quels objets, avec des méthodes. Sauf que pour l'accès aux variables, il faut penser à aux problèmes de concurrences d'accès (si un thread accède à une variable (en lecture, comme en écriture) qu'un autre est en train de modifier). Ce que le tutoriel de JM Doudoux, ainsi que d'autres tutoriels sur le site Developpez expliquent très bien (voir donc Synchronized, Lock...). Il y a éventuellement la problématique d'attendre que tous les threads aient terminé leur tâche avant d'envoyer une réponse complète. Pour ça tu peux regarder la classe CountDownLatch par exemple, mais on peut faire ça aussi avec Thread.join() aussi.
01/02/2016, 19h17
jeanmidudu
Citation:
Envoyé par joel.drigo

A mon avis, commence par mettre de côté cette notion de serveur : fait un programme qui prend en paramètre un fichier, point. Ensuite, tu pourras t'occuper de la notion de serveur (probablement offrant un service, restant à définir sous quel protocole), qui n'intervient pas dans le programme en lui-même.
Ensuite, il me semble inutile de chercher à lire un fichier en multi-thread : à moins d'avoir un dispositif physique capable de lire en parallèle des données sur le support physique, effet de cache mis à part, ça a plutôt tendance à tout ralentir. Fais la lecture entière en une fois, en chargeant le fichier dans une liste, par exemple (ou un tableau, peu importe). Ensuite, tu peux répartir le traitement de cette liste (ou tableau) entre n threads.
Ensuite :

Pour remplir la liste, soit tu utilises la méthode readAllLines de la classe Files qui va tout te charger d'un coup très facilement, soit tu utilises un BufferedReader pour lire le fichier ligne à ligne, que tu ajoutes à une liste au fur et à mesure. C'est du standard et tu trouveras l'exemple pourl le faire dans les FAQ.
A partir du moment où la liste est entièrement chargée, il n'est pas difficile de la découper en n sous-listes à procurer à n threads.
La communication entre threads se fait exactement comme pour une communication entre n'importe quels objets, avec des méthodes. Sauf que pour l'accès aux variables, il faut penser à aux problèmes de concurrences d'accès (si un thread accède à une variable (en lecture, comme en écriture) qu'un autre est en train de modifier). Ce que le tutoriel de JM Doudoux, ainsi que d'autres tutoriels sur le site Developpez expliquent très bien (voir donc Synchronized, Lock...). Il y a éventuellement la problématique d'attendre que tous les threads aient terminé leur tâche avant d'envoyer une réponse complète. Pour ça tu peux regarder la classe CountDownLatch par exemple, mais on peut faire ça aussi avec Thread.join() aussi.
J'ai déjà un programme qui compte le nombre de mots dans un fichier. Et je sais bien que ma demande est un peu stupide concernant l'intérêt de la méthode demandée, mais je ne fais pas ça pour le résultat, mais bien pour la compréhension.

Peut-être devrais-je reformuler ma demande de façon beaucoup plus radicale :
Pour ce qui du synchronized, lock et autres j'ai bien compris le fonction, aucun problème avec ça. Ce que je ne comprend c'est comment sont utilisés les Sockets pour communiquer entre les threads et/ou serveur. C'est là que je ne comprend strictement rien, et que nul n'est ici capable de fournir des explications claires et précises avec un exemple le plus simple du monde.

PS : En tout cas merci beaucoup pour le temps que tu me donnes!
01/02/2016, 19h27
joel.drigo

Les sockets c'est pour communiquer entre programmes. Les threads s'exécutent dans le serveur (c'est un programme qui s'exécute dans une JVM) : inutile d'utiliser des sockets pour communiquer entre threads. Maintenant, si l'idée, c'est que le serveur lance n programmes et leur envoie des données à traiter, et reçoive un résultat, la partie socket n'est qu'une communication standard client/serveur, qui ne dépend en rien de la notion de thread elle-même, si ce n'est qu'on peut gérer du multithread pour avoir des clients qui communiquent avec ce serveur en parallèle (en tout cas, ça n'a rien à voir avec les threads de répartition du traitement). Et pour ça aussi, tu as un tutoriel.
01/02/2016, 20h12
jeanmidudu

J'ai déjà vu ce tuto, et très honnêtement je n'y comprend strictement rien, si ce n'est que le serveur lance des sockets, je ne comprend absolument pas comment ils communiquent. Comment les informations transitent?

Je te propose une version simplifiée avec le moins de thread possible. Il n'y a qu'un seul thread pour le serveur (on pourrait s'en passer en faisant 2 programmes). L'envoi des données se fait la méthode écrire, la réception par la méthode lire (évidemment ça fonctionne dans les 2 sens : le serveur reçoit du client (lire), et envoie vers le client (écrire), et le client reçoit du serveur (lire) et envoie vers le serveur (écrire). J'ai utilisé le caractère \0 comme marqueur de fin de message. A noter que les méthodes lire et écrire ne peuvent être appelées qu'une seule fois par instance de socket.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.UnknownHostException;
import java.nio.charset.StandardCharsets;
import java.util.Scanner;
 
public class DemoSocket {
 
	private static final int PORT = 56565; // le port d'écoute du serveur
	private static final String COMMANDE_FIN = "au revoir"; // la commande pour arrêter le thread serveur
	private static final Scanner SCANNER = new Scanner(System.in); // un scanner pour lire les entrées de l'utilisateur
 
	public static void main(String[] args) {
 
		try {
			lanceServer();
			lanceClient();
		}
		catch(IOException e) {
			e.printStackTrace();
		}
	}
 
	private static void lanceClient() throws UnknownHostException, IOException {
 
		boolean running=true;
		do {
			System.out.println("CLIENT> Entrez un message pour le serveur (vous pouvez entrer plusieurs lignes).");
			System.out.println("CLIENT> Terminez par une ligne vide pour envoyer.");
			System.out.println("CLIENT> Envoyer le message "+COMMANDE_FIN+" pour terminer.");
			System.out.print("CLIENT> ");
			System.out.flush();
			String userInput = SCANNER.nextLine();
			if ( !userInput.trim().isEmpty() ) { // j'ignore quand l'utilisateur ne tape rien ou que des whitespaces
				final StringBuilder messageBuilder = new StringBuilder(); // je construis un message multi-ligne
				while( !userInput.trim().isEmpty() ) {
					if ( messageBuilder.length()!=0 ) {
						messageBuilder.append("\n");
					}
					messageBuilder.append(userInput);
					//if ( SCANNER.hasNextLine() ) {
						userInput = SCANNER.nextLine(); 
					/*}
					else {
						userInput = "";
					}*/
				}
				final String message = messageBuilder.toString();
				System.out.println("CLIENT> Envoi message au serveur... ("+message.length()+ " caractère"+(message.length()>1?"s":"")+" à envoyer");
				try(Socket client = new Socket("localhost",PORT)) {
					ecrire(client, message); // j'envoie le message au serveur
					final String reponse = lire(client); // je lis la réponse du serveur
					System.out.println("CLIENT> Le serveur a répondu : ");
					System.out.println(reponse);
				}
				if ( COMMANDE_FIN.equalsIgnoreCase(message) ) { // arrêt du client
					running=false;
				}    
			}
		} while(running);
		System.out.println("CLIENT> Fin programme.");
 
	}
 
	private static void lanceServer() {
 
		new Thread(()-> runServer()).start(); // j'exécute le serveur dans un thread
 
	}
 
	private static void runServer() {
		try(ServerSocket server = new ServerSocket(PORT)) { // je créé un serveur
			boolean running=true;
			do {
				try {
					try(final Socket socket = server.accept()) { // bloque le thread en attendant qu'un client se connecte
						System.out.println("SERVEUR> Un client s'est connecté...");
						final String messageClient = lire(socket);
						System.out.println("SERVEUR> Le client a envoyé : "); 
						System.out.println(messageClient); 
						System.out.flush();
						if ( COMMANDE_FIN.equalsIgnoreCase(messageClient) ) { // si le client envoie la commande de fin, alors arrêt du serveur
							running=false;
							ecrire(socket, "Demande arrêt serveur... OK.");
						}
						else {
							final String pluriel = messageClient.length()>1?"s":"";
							ecrire(socket, "Message bien reçu. "+messageClient.length()+" caractère"+pluriel + " reçu"+pluriel);
						}
					}
				} catch (IOException e) {
					e.printStackTrace();
				} 
			} while (running);
		} catch (IOException e1) {
			e1.printStackTrace();
		}
	}
 
	private static String lire(Socket socket) throws IOException {
		// attention on ne ferme le reader, parce que ça ferme la socket aussi (on ne pourrait plus écrire la réponse ensuite)
		final BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream(), StandardCharsets.UTF_8)); // j'ouvre le flux input qui me permet de récupérer ce que le client envoie
		final StringBuilder sb=new StringBuilder(); // je vais concaténer tout ce que le client envoie
		for(int read = reader.read(); read!=-1 && '\0'!=read ; read=reader.read()) { // je lis dans le flux dans qu'il y a quelque chose à lire, ou qu'on m'envoie pas \0 (fin de message)
			sb.append((char)read); // j'accumule les caractères lu (sauf le \0)
		}
		return sb.toString();
	}
 
	/**
         * Envoyer un message sur la socket
         * @param socket
         * @param string
         * @throws IOException 
         */
	private static void ecrire(Socket socket, String string) throws IOException {
		// attention on ne ferme pas le writer, parce que ça ferme la socket aussi (on ne pourrait plus écrire la réponse ensuite)
		// on peut utiliser un PrintWriter à la place du BufferedWriter, si ou veut pouvoir écrire dans le writer comme on le ferait avec System.out
		final BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream(), StandardCharsets.UTF_8));//j'ouvre le flux output qui me permet d'écrire vers l'"autre côté" (client ou serveur selon) 
		writer.write(string);
		writer.write('\0'); // j'envoie quelque chose qui permet au récepteur de savoir que j'ai envoyé tout mon message
		writer.flush(); // je force le vidage du buffer pour envoi
	}
 
}

02/02/2016, 13h59
jeanmidudu

Merci beaucoup, je vais y regarder attentivement pour essayer de comprendre, et te le ferais savoir si j'ai des questions. Merci encore!
04/02/2016, 09h58
jeanmidudu

Merci beaucoup, cela m'a été grandement utile!!! Je pense avoir compris maintenant, il ne me reste plus qu'à m'exercer. Franchement merci beaucoup!:D:resolu::merci:
04/02/2016, 10h00
joel.drigo

A noter en supplément, que tu peux transférer des octets au lieu de chaines de caractères (à la place de BufferedWriter, utiliser BufferedOutputStream, et à la place de BufferedReader, BufferedInputStream).