[JAVA] Sincronizzare Threads

[v1sc3rr4k]

Salve a tutti
Dovevo fare un programma che da client tramite server fa il prodotto scalare tra matrici quadrate, con la condizione che per ogni riga della prima il prodotto con l'intera seconda matrice venisse fatto da un server e così via. Quindi per matrici NxN ho bisogno di N server! Fin qui tutto bene. Il programma lavora e i calcoli sono corretti il problema è che non so come far attendere al Client che tutti i Threads lanciati abbiamo finito di elaborare i calcoli. Qualcuno ha qualche dritta da darmi sulla sincronizzazione oppure può consigliarmi sul codice. Ogni consiglio è ben accetto

import java.io.BufferedReader;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.Socket;
import java.util.Scanner;


public class Client extends Thread
{


public static void main(String args[]) throws IOException
{
Socket mainSocket = new Socket("localhost" , 1500);
DataOutputStream out = new DataOutputStream(mainSocket.getOutputStream());
BufferedReader in = new BufferedReader(new InputStreamReader(mainSocket.getInputStream()));
Scanner s = new Scanner(System.in);
int size, port;
float multiplying[][][] , result[][];

System.out.println("Dammi la dimensione delle matrici quadrate: ");
size = s.nextInt();
result = new float[size][size];
multiplying = new float[2][size][size];
System.out.println();

for(int index = 1 ; index < 3; index++)
{
System.out.println("Inserimento della matrice " + index + " !" );
System.out.println("__________________________________________" );

for(int j = 0 ; j < size ; j++)
for(int k = 0 ; k < size ; k++)
{
System.out.println("Dammi il prossimo elemento: ");
multiplying[index - 1][j][k] = s.nextFloat();
}
}

out.write(size);

// ricevo dal mainServer le porte dagli altri server chiamo l'oggetto client handler che avviera la connessione

for(int z = 1 ; z <= size ; z++)
{
System.out.println("Ricezione server " + z + " !");
port = in.read();
ClientHandler c = new ClientHandler(port , multiplying , result , size);
c.start();
}

}
}

L'altra classe:

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.Socket;


public class ClientHandler extends Thread
{
public ClientHandler(int port, float matrix[][][], float result[][], int size) throws IOException
{
this.socketN = new Socket("localhost" , port);
out = new DataOutputStream ( this.socketN.getOutputStream());
in = new DataInputStream ( this.socketN.getInputStream() );
this.matrix = matrix;
this.result = result;
this.size = size;
}

public void run()
{

try
{
int row = in.read();
out.write(size);

for(int i = 0 ; i < size; i++)
out.writeFloat(matrix[0][row][i]);

for(int i = 0; i < size ; i++)
for(int j = 0 ; j < size ; j++ )
out.writeFloat(matrix[1][i][j]);

for(int i = 0 ; i< size ; i++)
result[row][i] = in.readFloat();

//IL CLIENT DOVREBBE ASPETTARE CHE ARRIVO QUI
return;


}

catch(Exception e)
{
e.printStackTrace();
}
}

private Socket socketN;
private DataOutputStream out;
private DataInputStream in;
private float matrix[][][];
private float result[][];
private int size;
}

[clockover]

Guarda ho dato solo uno sguardo veloce ma il tuo problema è semplice da risolvere. Puoi utilizzare un array di semafori quindi la classe Semaphore del package java.util.concurrent.

Tu già sai quanti thread crei quindi è ancora più facile. La tua variabile size contiene questo valore quindi ti basta creare

Semaphore sem[] = new Semaphore[size];

aggiungi un campo Semaphore al tuo ClientHandler che verrà impostato dal costruttore.

dovresti fare una cosa del genere nel ciclo dove chiami ClientHandler

for(int z = 1 ; z <= size ; z++)
{
System.out.println("Ricezione server " + z + " !");
port = in.read();
sem[z-1] = new Semaphore(0);
ClientHandler c = new ClientHandler(port , multiplying , result , size, sem[z-1]);
c.start();
}
for(Semaphore s:sem){
    try{
        s.acquire();
    }catch(InterruptedException iee){
        gestisci l'eccezione
    }
}

mentre all'interno di ClientHandler, li dove dici che devi aspettare, inserisci, supponendo che sem sia un riferimento all'oggetto semaforo passato dal Client, sem.release()

non so se sono stato chiaro ma a quest'ora posso essere perdonato

[brodaglia]

Non so se è questa la soluzione che cercavi, però se vuoi qualcosa del tipo :
1.Genero il server
2.Faccio i calcoli sulla mia matrice
3.Notifico che ho finito
4.Genero l'altro server
5.Faccio i calcoli sulla mia matrice
6.Notifico che ho finito
etc etc
allora potresti fare qualcosa del genere :

import java.io.BufferedReader;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.Socket;
import java.util.Scanner;


public class Client extends Thread
{

public static void main(String args[]) throws IOException
{
Socket mainSocket = new Socket("localhost" , 1500);
DataOutputStream out = new DataOutputStream(mainSocket.getOutputStream());
BufferedReader in = new BufferedReader(new InputStreamReader(mainSocket.getInputStream()));
Scanner s = new Scanner(System.in);
int size, port;
float multiplying[][][] , result[][];

System.out.println("Dammi la dimensione delle matrici quadrate: ");
size = s.nextInt();
result = new float[size][size];
multiplying = new float[2][size][size];
System.out.println();

for(int index = 1 ; index < 3; index++)
{
System.out.println("Inserimento della matrice " + index + " !" );
System.out.println("__________________________________________" );

for(int j = 0 ; j < size ; j++)
for(int k = 0 ; k < size ; k++)
{
System.out.println("Dammi il prossimo elemento: ");
multiplying[index - 1][j][k] = s.nextFloat();
}
}

out.write(size);

// ricevo dal mainServer le porte dagli altri server chiamo l'oggetto client handler che avviera la connessione

for(int z = 1 ; z <= size ; z++)
{
System.out.println("Ricezione server " + z + " !");
port = in.read();

ClientHandler c = new ClientHandler(port , multiplying , result , size);

//************Sincronizzo l'oggetto thread creato così evito 
accessi multipli
synchronized (c) {
		c.start();
//***********Creo la condizione per far attendere gli altri thread, 
l'oggetto verrà rilasciato se da qualche parte qualcuno chiamerà
 un notify o notifyAll sullo stesso oggetto
                             c.wait();

                       }

}
}

L'altra classe dovrebbe essere cosi :

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.Socket;


public class ClientHandler extends Thread
{
public ClientHandler(int port, float matrix[][][], float result[][], int size) throws IOException
{
this.socketN = new Socket("localhost" , port);
out = new DataOutputStream ( this.socketN.getOutputStream());
in = new DataInputStream ( this.socketN.getInputStream() );
this.matrix = matrix;
this.result = result;
this.size = size;
}

public void  run() {
		
//****Sincronizzo anche questa istanza per stare tranquilli
		synchronized (this) {

		//*********Chiamo il metodo delle matrici che ho 
diviso per chiarezza
		doSomething();


//**********Notifico a tutti di rilasciare il lock sull'oggetto
			this.notifyAll();
		}
	}


//*************Sincronizzo anche questo per stare tranquilli :D
synchronized public void doSomething()
	{
		try {
			int row = in.read();
			out.write(size);

			for (int i = 0; i < size; i++)
				out.writeFloat(matrix[0][row][i]);

			for (int i = 0; i < size; i++)
				for (int j = 0; j < size; j++)
					out.writeFloat(matrix[1][i][j]);

			for (int i = 0; i < size; i++)
				result[row][i] = in.readFloat();

			// IL CLIENT DOVREBBE ASPETTARE CHE ARRIVO QUI
			
			return;

		}

		catch (Exception e) {
			e.printStackTrace();
		}
		
	}


private Socket socketN;
private DataOutputStream out;
private DataInputStream in;
private float matrix[][][];
private float result[][];
private int size;
}

[PGI-Bis]

usa un Semaphore con N permits, clienthandler fa un acquire(N) e ciascuno dei client fa un release(). N è il numero di client.

[v1sc3rr4k]

Grazie mille a tutti, alla fine ho risolto con l'utilizzo della classe Semaphore!

Se ho ben capito così facendo mantengo il parallelismo nei calcoli ma ho la sequenzialità nella ricezione dei risultati? Oppure semplicemente forzo il Client ad aspettare per ognuno dei semafori?

Comunque ancora grazie a tutti !!!