Discussion :

[ederf]

bonjour,


J'aimerais connaître la différence entre Tread.sleep() et wait().


merci d'avance

[adiGuba]

Salut,



Thread.sleep() se contente d'endormir le Thread courant pendant un laps de temps.


Les méthodes wait() et wait(long) hérité de la classe Object permettent d'effectuer de la synchronisation entre les threads. Par exemple tu peut utiliser un objet o partagé entre deux threads.

Par exemple si dans ton premier thread tu as le code suivant :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
        synchronized (o) { // demande un lock sur l'objet 'o'
            o.wait();    // libère le lock sur 'o' et attend d'être notifié
        }

Le thread se mettra en attente (infini dans ce cas).


Si dans un second thread tu as le code suivant :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
        synchronized (o) { // demande un lock sur l'objet 'o'
            o.notify();    // réveille tous les threads qui sont en wait() sur 'o'
        }

Le premier thread pourra alors sortir de la méthode wait() (après avoir récupéré le lock sur o).

Cela permet ainsi de synchroniser les threads entre eux...



Si tu t'intérresse à la synchronisation des threads, tu peux également jeter un coups d'oeil aux packages java.util.concurrent, java.util.concurrent.atomic et java.util.concurrent.locks...

a++

[ederf]

Je te remercie pour ta réponse.

Je croyais que les fonctions Thread.sleep(1) et wait(1) étaient les memes.

En fait je faisais appel à wait(1) dans une méthode synchronized et ça m'enlevait le verrou c'est bien ça?.

Merci

[adiGuba]

Je croyais que les fonctions Thread.sleep(1) et wait(1) étaient les memes.

wait() peut être "réveillé" par un appel à notify() ou notifyAll() depuis un autre thread...

En fait je faisais appel à wait(1) dans une méthode synchronized et ça m'enlevait le verrou c'est bien ça?.

Oui cela enlève le verrou pendant que tu es à l'intérieur de la méthode wait(), et tu le récupères en sortant de la méthode (une fois qu'il est disponible bien sûr)...

a++

[Gfx]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
        synchronized (o) { // demande un lock sur l'objet 'o'
            o.notify();    // réveille tous les threads qui sont en wait() sur 'o'
        }

notify() ne reveille qu'un seul Thread, c'est notifyAll() qui les reveille tous. Il est egalement conseille d'ecrire le wait() ainsi :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
        synchronized (o) { // demande un lock sur l'objet 'o'
            while (!condition_de_reveil) {
                o.wait();    // libère le lock sur 'o' et attend d'être notifié
            }
        }

Cela evite non seulement des bugs de programmation mais surtout les "spurious wakes" qui peuvent survenir d'apres les specifications du langage Java. Cela signifie qu'il se peut qu'un Thread en wait() soit reveille "tout seul". En ajoutant la boucle sur la condition de reveil du thread on garantit que le reveil ne sera effectif qu'au bon moment.

[adiGuba]

notify() ne reveille qu'un seul Thread, c'est notifyAll() qui les reveille tous.

Oui en effet j'ai parlé trop vite

Cela evite non seulement des bugs de programmation mais surtout les "spurious wakes" qui peuvent survenir d'apres les specifications du langage Java.

+1, et cela permet également d'éviter les blocages dans le cas où le notify() est exécuté avant le wait()...

a++

[benjiprog]

J'ai fait un petit programme de synchronisation le but est de synchroniser le calcul du carré du nombre avec l'affichage
le voilà si ca peut vous aider :
Fichier de la classe Nombres

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
public class Nombres {
 
	private int nb,resu;
	private boolean pret=false;
 
	public synchronized void calc () throws InterruptedException
	{
		if (!pret) 
		{
			nb++;
			resu=nb*nb;
			pret=true;
			notifyAll();  //Libere le verrou et donne la possibilité au thread en attente
		}					// d'être executer
		else
		{
			wait();   //Mise en attente du thread et rend le verrou a l'environnement
		}			//pour qu'il puisse l'attribuer a l'autre methode synchro
	}
	public synchronized void aff () throws InterruptedException
	{
		try
		{
			if (pret)
			{
				System.out.println(nb+" a pour carre "+resu);
				pret=false;
				notifyAll();   //Libere le verrou et donne la possibilité au thread en attente
			}					// d'être executer
			else
			{
				wait();   //Mise en attente du thread et rend le verrou a l'environnement
			}			//pour qu'il puisse l'attribuer a l'autre methode synchro
		}
		catch (InterruptedException err) {}
	}
}
class Thcalc extends Thread {
 
	private Nombres nomb;
 
	public Thcalc (Nombres nomb)
	{
		this.nomb=nomb;
	}
	public void run ()
	{
		try
		{
			while (!interrupted())
			{
				nomb.calc();
				sleep(10);
			}
		}
		catch (InterruptedException err) {}
	}
}
class Thaff extends Thread {
 
	private Nombres nomb;
 
	public Thaff (Nombres nomb)
	{
		this.nomb=nomb;
	}
	public void run ()
	{
		try
		{
			while (!interrupted())
			{
				nomb.aff();
				sleep(15);
			}
		}
		catch(InterruptedException err) {}
	}
}

Fichier de la classe main

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
public class Principal {
 
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Nombres nb = new Nombres();
		Thcalc t1 = new Thcalc(nb);
		Thaff t2 = new Thaff(nb);
 
		System.out.print("Taper sur entree pour terminer les calculs\n");
		t1.start();   t2.start();
		Clavier.lireString();
		t1.interrupt();   t2.interrupt();
 
	}
 
}

J'ai entendu dire qu'il fallait toujours placer les déclarations des champs a la fin de la classe est ce vrai?