[JAVA] Lettura di riga da file con più thread che la processano

[devildantej]

Ciao gente, sto cercando di fare un piccolo programmino che fa delle simulazioni.
Il mio scopo è quello di avere un thread che legge ogni singola riga da un file testo e più thread che processano da quella riga letta.
Una riga contiene semplicemente un numero (1 o 2 o 3).
Sono quasi riuscito a produrre un codice funzionante, perchè funziona correttamente fino a 3 thread che processano.
Alzando invece il numero comincio a perdere il controllo dei thread: l'ordine si sballa e saltano la lettura di alcune righe.

Il mio problema principale è quello di riuscire a fare in modo che i thread una volta finito di processare, vadano in wait, però l'ultimo
deve anche avvisare che tutti i thread hanno finito di processare. Così con la chiamata si fa partire la lettura di un'altra riga

Ho copiato i pezzi più importanti della classe che fa da monitor

// Scrivo il colore letto da file in un vettore e poi aspetto
public synchronized void writeline(int iColor){
	iThreadLogReading = iThreadLogWorking;
	for (int i = 0; i < iThreadLogWorking; i++){
		vecStackColors.push(iColor);
	}
	notifyAll();
	while (!vecStackColors.empty()){
		try {
			wait();
		} catch (InterruptedException e) {
		}
	}
}

// Leggo il colore e poi processo	
public synchronized int readline(){
	while (vecStackColors.empty()){
		try {
			wait();
		} catch (InterruptedException e) {
		}
	}

	int iReturn = vecStackColors.lastElement();
	return iReturn;
}

// Processato aspetto che tutti i thread abbiano processato
// e poi notifico di leggere un'altra riga
public synchronized void readlineEnd(){
	vecStackColors.pop();

	if (vecStackColors.empty()) {
		notifyAll();
	} else {
		try {
			wait();
		} catch (InterruptedException e) {
		}
	}
	
	try {
		wait();
	} catch (InterruptedException e1) {
	}		
}

[andbin]

Originariamente inviato da devildantej
Sono quasi riuscito a produrre un codice funzionante, perchè funziona correttamente fino a 3 thread che processano.
Alzando invece il numero comincio a perdere il controllo dei thread: l'ordine si sballa e saltano la lettura di alcune righe.

Il codice che hai scritto è fumoso, poco logico e quindi molto "critico".

Se ti è stato chiesto esplicitamente (es. per questioni "didattiche") di usare la condition queue intrinseca degli oggetti (appunto i wait()/notify()/notifyAll()) allora ok, è un conto.
Se invece non c'è questa necessità, allora evita di usare questa sincronizzazione a "basso livello". Usa le classi e le collezioni di Java 5 dedicate alla "concurrency".

L'altra questione è capire come deve essere la sequenza della distribuzione. Hai 1 scrittore e N lettori. Gli scenari possibili sono questi:

a) Tutti i lettori devono processare il valore corrente prima che lo scrittore possa inviare un nuovo valore.

b) Ogni lettore processa i valori in modo indipendente dagli altri lettori. L'unica cosa che conta è che ogni singolo lettore processi un valore appena è disponibile.

Mi sembrerebbe di capire che il tuo è il caso a)

[devildantej]

Hai capito in pieno la mia idea. L'idea di usare il wait() e notifyAll() è perchè non pensavo ci fossero altri metodi. Purtroppo non conosco tante classi di java.

Il programma che sto facendo è prettamente amatoriale quindi non ho obblighi.
Se mi indichi qualche guida o esempio delle classi di Java 5 dedicate alla "concurrency" sarei ben lieto di imparare.

L'idea è appunto:
- Scrittore produce 5 (ad esempio) colori per 5 thread che processeranno. Aspetta.
- Ogni lettore consuma un colore, e da quel colore processa (ogni consumatore ha una diversa logica a partire dello stesso colore). Finito di processare, il lettore deve aspettare che tutti i lettori abbiano processato.
- L'ultimo lettore deve anche avvisare lo scrittore.
- Scrittore produce altri 5 colori per 5 thread che processeranno. Aspetta.
- Ecc...