[JAVA] Accesso a file e metodi "synchronized"

[padrino9008]

Salve a tutti e Buon Natale volevo chiedervi sapete se le classi standard di java hanno tutti i metodi synchronized??? xk nella documentazione non c'è scritto nulla, quindi non sò quali sono synchronized e quali non lo sono.

Grazie mille distinti saluti.

[andbin]

Originariamente inviato da padrino9008
volevo chiedervi sapete se le classi standard di java hanno tutti i metodi synchronized??? xk nella documentazione non c'è scritto nulla, quindi non sò quali sono synchronized e quali non lo sono.

Dipende quali classi .... se una classe del framework è "thread safe" di norma è chiaramente indicato (nella documentazione javadoc, si intende) e anzi, talvolta è anche indicato che una classe non è thread safe per mettere molto bene in guardia il programmatore.

Precisa quali classi intendi.

[padrino9008]

Ecco il codice: genero 4 Thread che hanno Ognuno il proprio oggetto PrintWriter però accedono allo stesso file, nell'esecuzione del programma tutto funziona perfettamente solo che non so se è un caso oppure l'accesso al file in qualche modo è già gestito dalla JVM facendo entrare un Thread alla volta.

import java.net.*;
import java.io.*;
public class SportelloThread implements Runnable{
	private Tagliando temp=null;
	private int name=0;
	private SportelloThreadGrafico g;
	
	public SportelloThread(int n,SportelloThreadGrafico h){
		g=h;
		name=n;
		}
		
	public void run(){
		int numclienti1=0;
		int numclienti2=0;
		try{
		PrintWriter out=new PrintWriter(new FileWriter("infospo.txt",true));
		while(true){
			Socket cs=new Socket("127.0.0.1",17001);
			ObjectInputStream in=new ObjectInputStream(cs.getInputStream());
			temp=(Tagliando)in.readObject();
			if(temp!=null) {
				if(temp.getType()==0) {
					System.out.println("==============\n
                                                          Sono lo Sportello: "+name+" Ho servito: \n"
                                                          +temp+
                                                          "Cliente Numero: " +numclienti1+
                                                          "\n==================");
					(g.getSg()).setGrafico(name,temp,numclienti1);
					out.println("Sportello: "+name+" Tipo1: "+numclienti1);
					out.flush();
					numclienti1++;
					Thread.sleep((int)(Math.random()*3000));
					}
				else {
					System.out.println("==============\n
                                                           Sono lo Sportello: "+name+" Ho servito: \n"
                                                           +temp+
                                                           "Cliente Numero: " +numclienti2+
                                                           "\n==================");
					(g.getSg()).setGrafico(name,temp,numclienti2);
					out.println("Sportello: "+name+" Tipo2: "+numclienti2);
					out.flush();
					numclienti2++;
					Thread.sleep((int)(Math.random()*3000));
					}
				}
			in.close();
			cs.close();
			}
		}catch(UnknownHostException e){
			System.out.println("Il server non risponde\n");
			e.printStackTrace();
			}
		catch(IOException e){
			System.out.println("Errore lettura\n");
			e.printStackTrace();
			}
		catch(ClassNotFoundException e){
			System.out.println("Classe Oggetto non trovata\n");
			e.printStackTrace();
			}
		catch(InterruptedException e){
				System.out.println("Errore Interrupted\n");
				e.printStackTrace();
				}
		}
	}

[andbin]

Originariamente inviato da padrino9008
Ecco il codice: genero 4 Thread che hanno Ognuno il proprio oggetto PrintWriter però accedono allo stesso file, nell'esecuzione del programma tutto funziona perfettamente solo che non so se è un caso oppure l'accesso al file in qualche modo è già gestito dalla JVM facendo entrare un Thread alla volta.

Le classi di I/O, in linea generale, non sono thread-safe. I Reader/Writer sono in grado di trattare un oggetto che fa da "lock", che viene passato dalle sottoclassi. Il discorso sarebbe un po' lungo e ti rimando quindi alla documentazione javadoc (e magari ai sorgenti del framework che sono molto più esplicativi e interessanti da vedere).

Nel tuo caso però non è tanto un problema di thread safety a livello di uso degli oggetti, perché ogni thread ha il suo FileWriter e il suo PrintWriter.

Dici però bene che tutti i thread accedono allo stesso medesimo file e questo è un altro discorso e il problema teoricamente c'è comunque. Che sia la stessa applicazione Java che scrive da più thread sullo stesso file, che siano due applicazioni Java distinte che scrivono sullo stesso file, che siano applicazioni molto diverse (es. una Java, una "nativa") che scrivono sullo stesso file, in ogni caso non c'è affatto alcuna garanzia che vada tutto "bene".

È probabile che nel tuo caso non noti cose strane magari solo perché i thread girano con tempistiche aleatorie dovute a quei sleep con tempo casuale. Ma le possibilità che tu possa vedere testo mescolato (e magari anche male) ci sono, esistono.

Quindi la cosa più "pulita" che puoi fare è incapsulare la logica di scrittura del file in una classe a parte (che deve essere thread-safe, quindi deve avere metodi "sincronizzati") e poi passare 1 oggetto di questa classe ai tuoi thread.


P.S. Vedo che il tuo runnable riceve un SportelloThreadGrafico. Se alle tue istanze di SportelloThread passi lo stesso oggetto SportelloThreadGrafico, il problema di thread safety ci sarebbe per questo oggetto. Ma non so cosa fa, non so cosa è/fa getSg() e non so che oggetto restituisce. Questo devi valutarlo tu.

[padrino9008]

quei metodi sono tutti synchronized, servono per visulalizzare il contenuto nella grafica che gira su un altro thread.

[padrino9008]

Ho appena provato a lanciare nuovamente il programma però anziché usare 4 Thread per aumentare la probabilità che due Thread eseguano nello stesso momento l'operazione di scrittura nel file => ho inserito 20 Thread il risultato è lo stesso non si creano errori nel file, dunque ho riprovato usando 101 Thread => nessuna anomalia nel file.

tempo esecuzione 200 secondi 3:20 minuti in tutti i casi.

forse non è un caso che non ci siano anomalie nel file, forse la JVM fa si che un solo Thread per volta entra nel file.