[JAVA] uno strano caso (threads)

[zanardi84]

Nel mio allargare l'orizzonte di java mi sto imbattendo nei problemi di concorrenza dei thread. Ho creato una semplice applicazione che rappresenta 3 cronometri. Uno stampa il tempo ogni secondo, uno ogni 2 e uno ogni 3. Dell'output me ne frego perchè non è il mio attuale scopo..

Ho notato che sbaglia il tempo quando stampa nel caso dei 2 o 3 secondi. Ok, si legge che non sempre in un metodo sleep si può avere la precisione, ma nel mio caso ad un certo punto sbaglia anticipando! Non vorrei che ci fossero problemi nel mio codice.

Queste sono le classi

public class Orologio implements Runnable
{
	private int secondi = 0;
	
	public void setSecondi()
	{
		secondi++;
	}
	
	public int getSecondi()
	{
		return secondi;
	}

	@Override
	public void run()
	{
		while(true)
		{
			System.out.println(this.getSecondi());
			try
			{
				Thread.sleep(1000);
			}
			catch(InterruptedException e){}
			this.setSecondi();
		}
	}
}

public class Temporizzatore implements Runnable
{

	private int secondi;
	private String nome;
	private Orologio o;
	public Temporizzatore(int secondi, String nome, Orologio o)
	{
		this.secondi = secondi;
		this.nome= nome;
		this.o = o;
	}
	
	@Override
	public void run()
	{
		while(true)
		{
			System.out.println(nome+" "+o.getSecondi());
			try
			{
				Thread.sleep(secondi*1000);
			}
			catch(InterruptedException e){}
		}
		
	}

}

public class Main
{

	/**
	 * @param args
	 */
	public static void main(String[] args)
	{
		Orologio o = new Orologio();
		Thread orologio = new Thread(o);
		Thread t1 = new Thread(new Temporizzatore(1, "Primo cronometro", o));
		Thread t2 = new Thread(new Temporizzatore(2, "Secondo cronometro", o));
		Thread t3 = new Thread(new Temporizzatore(3, "terzo cronometro", o));
		orologio.start();
		t1.start();
		t2.start();
		t3.start();

	}

}

[franksisca]

non capisco a cosa ti serve la classe orologio sinceramente.

dovrebbe essere tutto ok, la differenza è randomatica oppure pensi che sia abbastanza "sequenziale"?

[wingman87]

Può essere che invece di essere in anticipo i temporizzatori sia in ritardo l'orologio. Anzi, è più che probabile visto che in tre secondi l'orologio si sveglia 3 volte, aggiungendo un po' di overhead in più rispetto al temporizzatore che si sveglia solo una volta ogni 3 secondi.

[zanardi84]

Originariamente inviato da franksisca

non capisco a cosa ti serve la classe orologio sinceramente.

dovrebbe essere tutto ok, la differenza è randomatica oppure pensi che sia abbastanza "sequenziale"?

Come si può fare senza scrivere la classe orologio?

La differenza, anche lanciando il solo t3 è, se non ricordo male, tra 6 e 9 in cui indica 8. Poi prosegue correttamente.

[franksisca]

Originariamente inviato da zanardi84

Come si può fare senza scrivere la classe orologio?

La differenza, anche lanciando il solo t3 è, se non ricordo male, tra 6 e 9 in cui indica 8. Poi prosegue correttamente.

scusa mi ero perso un orologio.start()....avresti potuto implementare la logica nella Temporizzatore, ma va bene anche così.

Se lo ha fatto solo 8 invece di 9 e anche randomaticamente, credo sia proprio un problema "fisico" di VM. hai provato con intervalli più grandi?

[zanardi84]

Originariamente inviato da franksisca

scusa mi ero perso un orologio.start()....avresti potuto implementare la logica nella Temporizzatore, ma va bene anche così.

Se lo ha fatto solo 8 invece di 9 e anche randomaticamente, credo sia proprio un problema "fisico" di VM. hai provato con intervalli più grandi?

Ho lanciato un solo thread con intervallo 5 e mi visualizza a 4, poi ogni 5 sino ad un minuto di durata della prova.

[franksisca]

Originariamente inviato da zanardi84

Ho lanciato un solo thread con intervallo 5 e mi visualizza a 4, poi ogni 5 sino ad un minuto di durata della prova.

quindi probabilmente è un problema di startup della VM

[zanardi84]

Grazie.

[banryu79]

Sarò breve, non per spocchia ma per fretta, quindi porta pazienza, ma ti rispondo con questa lista:

+ il campo 'secondi' dell'istanza di Orologio è condiviso da 4 thread, tutti ci accedono in lettura e solo uno ci accede in scrittura.

+ letture e scritture sul campo 'secondi' non sono sincronizzate
(questo significa che anche se il thread scrittore ha aggiornato il campo 'secondi' un'altro thread lettore potrebbe continuare a leggere il vecchio valore)

+ Per imparare il multithreading devi:
A) Avere dell'ottimo materiale di studio;
B) Studiare il Memory Model del linguaggio.

Altrimenti, IMHO, perdi solo tempo.
Se non hai un buon testo sottomano, come punto di partenza puoi usare questa lesson sulla Concurrency, spiega bene le basi minime da sapere:
http://docs.oracle.com/javase/tutori...ncy/index.html


Altri problemi nel tuo esempio, che per ora puoi lasciar perdere:

+ Thread.sleep non è una garanzia di precisione (non per colpa sua, ma per la natura del timer di sistema (SO) e dello scheduler di sistema (SO)) il che tra l'altro incide sull'aspetto descritto nel prossimo punto...

+ System.out viene condiviso dai 4 thread; il metodo 'println' è thread safe ma nel tuo programma l'ordine di accesso alla risorsa non è sincronizzato tra i thread e chi primo arriva meglio alloggia, quindi capita che l'ordine di stampa dei messaggi di un thread 'temporizzatore' rispetto al thread 'orologo' non sia come ti aspetteresti (desincronizzato).

EDIT:
Tanto per la cronaca, due esempi di output di due successive esecuzioni del tuo programma sulla mia macchina (SO windows)

run:
0
Secondo cronometro 0
Primo cronometro 0
terzo cronometro 0
1
Primo cronometro 1
2
Primo cronometro 2
Secondo cronometro 2
3
Primo cronometro 3
terzo cronometro 3
Secondo cronometro 3
4
Primo cronometro 3
5
Primo cronometro 5
6
Secondo cronometro 6
terzo cronometro 6
Primo cronometro 6
7
Primo cronometro 7
Primo cronometro 7
8
Secondo cronometro 7
9
Primo cronometro 9
terzo cronometro 9
10
Primo cronometro 10
Secondo cronometro 10
11
Primo cronometro 11
terzo cronometro 11
Primo cronometro 12

run:
0
Primo cronometro 0
Secondo cronometro 0
terzo cronometro 0
1
Primo cronometro 1
2
Secondo cronometro 2
Primo cronometro 2
3
Primo cronometro 3
terzo cronometro 3
4
Primo cronometro 4
Secondo cronometro 4
Primo cronometro 4
5
Primo cronometro 5
terzo cronometro 5
Secondo cronometro 5
6
Primo cronometro 6
7
Secondo cronometro 7
Primo cronometro 7
8
Primo cronometro 8
terzo cronometro 8
9
Secondo cronometro 9
Primo cronometro 9
10
Primo cronometro 10
11
Primo cronometro 11
Secondo cronometro 11
terzo cronometro 11

[franksisca]

Originariamente inviato da banryu79

Sarò breve, non per spocchia ma per fretta, quindi porta pazienza, ma ti rispondo con questa lista:

+ il campo 'secondi' dell'istanza di Orologio è condiviso da 4 thread, tutti ci accedono in lettura e solo uno ci accede in scrittura.

+ letture e scritture sul campo 'secondi' non sono sincronizzate
(questo significa che anche se il thread scrittore ha aggiornato il campo 'secondi' un'altro thread lettore potrebbe continuare a leggere il vecchio valore)

+ Per imparare il multithreading devi:
A) Avere dell'ottimo materiale di studio;
B) Studiare il Memory Model del linguaggio.

Altrimenti, IMHO, perdi solo tempo.
Se non hai un buon testo sottomano, come punto di partenza puoi usare questa lesson sulla Concurrency, spiega bene le basi minime da sapere:
http://docs.oracle.com/javase/tutori...ncy/index.html

menomale che il mio ex prof di SO non legge, altrimenti mi straccerebbe la laurea!!!

[zanardi84]

Ispirandomi alla soluzione del problema dei lettori e degli scrittori che sono riuscito a risolvere (non nel thread che ho postato) o provato ad implementare nuovamente i cronometri (intanto una versione con uno solo), ma non sembra funzionare. Ecco il codice

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;


public class Orologio 
{
	private int secondi = 0;
	private boolean nuovo = true;
	private Lock lock = new ReentrantLock();
	private Condition isVecchio = lock.newCondition();
	private Condition isNuovo = lock.newCondition();
	
	
	
	public synchronized void setSecondi() throws InterruptedException
	{
		lock.lock();
		try
		{
			while(nuovo==true)
				isNuovo.await();
			nuovo=true;
			secondi++;
		}
		finally
		{
			lock.unlock();
		}
	}
	
	public synchronized int getSecondi() throws InterruptedException
	{
		lock.lock();
		try
		{
			while(nuovo==false)
				isVecchio.await();
			nuovo=false;
		}
		finally
		{
			lock.unlock();
		}
		return secondi;
	}
}

public class Display implements Runnable
{

	private Orologio o;
	private int intervallo;
	
	public Display(Orologio o, int intervallo)
	{
		this.o = o;
		this.intervallo = intervallo;
	}
	
	@Override
	public void run()
	{
		try
		{
			while(true)
			{
				System.out.println(o.getSecondi());
				try
				{
					Thread.sleep(intervallo*1000);
				}
				catch(InterruptedException e){}
			}
		}
		catch(InterruptedException e){}
	}
}

public class Cronometro implements Runnable
{
	private Orologio o;
	
	public Cronometro(Orologio o)
	{
		this.o = o;
	}
	
	@Override
	public void run()
	{
		// TODO Auto-generated method stub
		try
		{
			while(true)
			{
				o.setSecondi();
				try
				{
					Thread.sleep(1000);
				}
				catch(InterruptedException e){}
			}
		}
		catch(InterruptedException e){}
	}
}

public class Main
{

	/**
	 * @param args
	 */
	public static void main(String[] args)
	{
		// TODO Auto-generated method stub
		Orologio o = new Orologio();
		Cronometro c = new Cronometro(o);
		Display d1 = new Display(o, 1);
		Thread t1 = new Thread(c);
		Thread t2 = new Thread(d1);
		t1.start();
		t2.start();

	}

}

[banryu79]

Originariamente inviato da zanardi84

Ispirandomi alla soluzione del problema dei lettori e degli scrittori che sono riuscito a risolvere (non nel thread che ho postato) o provato ad implementare nuovamente i cronometri (intanto una versione con uno solo), ma non sembra funzionare.

Vedo un'imprecisione e un errore:
- getSecondi e setSecondi sono thread-safe grazie all'uso di un oggetto ReentrantLock: non serve dichiararli synchronized.
- Chiami condition.await() ma ti manca il corrispettivo condition.signal() per risvegliare i thread in attesa...
(Vedi esempio nella documentazione di Condition, qui)

IMHO -> Ripeto: perdi solo tempo a tentare di studiare gli aspetti di "programmazione concorrente" a colpi di esercizi...

[zanardi84]

Hai del materiale su cui studiare oltre al tutorial di java (di cui ho il cartaceo in italiano comprato tempo fa, ma lo trovo un po' troppo stringato)? Mi piacerebbe se ci fosse qualcosa di Cay Horstmann sul cui libro ho studiato per i fondamenti, un autore MOLTO valido secondo me..

[banryu79]

Originariamente inviato da zanardi84

Hai del materiale su cui studiare oltre al tutorial di java (di cui ho il cartaceo in italiano comprato tempo fa, ma lo trovo un po' troppo stringato)? Mi piacerebbe se ci fosse qualcosa di Cay Horstmann sul cui libro ho studiato per i fondamenti, un autore MOLTO valido secondo me..

Io presi a suo tempo:
Java Concurrency in Practice di Brian Goetz.

L'ho trovato ottimo.
Ho appena visto che c'è su amazon.it, e il prezzo è calato parecchio (veco che costa 19 euro). Secondo me un affare

[zanardi84]

Riprendo il discorso per cercare di fare il punto sugli accorgimenti necessari per avere la thread safety.

1) Dichiarare private le variabili di istanza degli oggetti: Condizione necessaria ma non sufficiente.

2) Immutabilità degli oggetti per sfruttare l'atomicità dei costruttori. Al costruttore si passano i parametri e le variabili di istanza sono dichiarate final.
La modifica ad esse si ottiene con un costruttore, o lo stesso in base alle necessità e si ritorna un nuovo oggetto coi campi aggiornati.

3) Uso dei lock impliciti.

4) Uso dei lock espliciti + oggetti condition dal package concurrent.


Sull'uso dei lock espliciti ho un dubbio riguardo all'uso delle variabili condition applicate al problema per cui ho aperto il topic.
Con un solo scrittore e più lettori mi vien da pensare che sia necessario fare in modo che tutti i lettori che si svegliano leggano prima che lo scrittore possa scrivere un nuovo dato. Una cosa di questo genere.

public void scrivi() throws InterruptedException
	{
		scrittori++;
		lock.lock();
		try
		{
			while(lettori > 0)
			{
				scrittura.await();
			}
			secondi = secondi + 1;
			scrittori--;
			lettura.signalAll();
		}
		finally
		{
			lock.unlock();
		}
	}
	
	public int leggi() throws InterruptedException
	{
		lettori++;
		lock.lock();
		try
		{
			
			while(scrittori > 0)
			{
				lettura.await();
			}
			lettori --;
			scrittura.signalAll();
			
			// ritorno un valore considerato private
			// NON SI FA! Risolvere.
			return secondi;
		}
		finally
		{
			lock.unlock();
		}
	}

Il dubbio che ho è se la coda d'attesa che ho inserito con i contatori lettori e scrittori sia necessaria o meno.