Synchronisation de processus

Olivier wrote:

Bonjour

J'aimerais savoir comment faire synchoniser deux processus A et B
en java fonctionnant de la manière suivante :

A s'endort
B fait des traitements, et quand une donnée est disponible après
calculs, réveille A. Puis A se rendort à nouveau, B continue de
calculer et réveille A, ainsi de suite...

Et puis comment faire aussi lorsque A représente plusieurs processus,
en gros, c'est plusieurs threads qui se disent à partir d'un signal
de B qu'ils ont le droit de travailler.

J'ai fait ça, je sais pas ce que vous en pensez (le programme n'a pas
de fin, mais c'est juste pour tester la synchro) :

public class Synchro
{
// simule un calcul, on demande à l'utilisateur d'appuyer sur entrée
public class Calcul extends Thread
{
private Thread recup;

public Calcul(Thread recup)
{
this.recup = recup;
}

public void run()
{
System.out.println("Tapez entrée pour interrompre le thread");
do
{
try
{
System.in.read(); // simule un calcul qui prend du temps
}
catch (IOException e) {}
recup.interrupt();
}
while (true);
}
}

public class Recup extends Thread
{
public Recup() {}

public void run()
{
do
{
try
{
sleep(2000000000);
}
catch (InterruptedException e) {}
System.out.println("interrompu !"); // on peut utiliser les
// résultats du calcul
}
while (true);
}
}

public Synchro()
{
Recup recup = new Recup();
Calcul calcul = new Calcul(recup);
recup.start();
calcul.start();
}

public static void main(String[] args)
{
new Synchro();
}
}

oliv

olivier girant <olivier.girant@_libre_.fr> wrote:

Olivier wrote:

Bonjour

J'aimerais savoir comment faire synchoniser deux processus A et B
en java fonctionnant de la manière suivante :

A s'endort
B fait des traitements, et quand une donnée est disponible après
calculs, réveille A. Puis A se rendort à nouveau, B continue de
calculer et réveille A, ainsi de suite...

Et puis comment faire aussi lorsque A représente plusieurs processus,
en gros, c'est plusieurs threads qui se disent à partir d'un signal
de B qu'ils ont le droit de travailler.

J'ai fait ça, je sais pas ce que vous en pensez (le programme n'a pas
de fin, mais c'est juste pour tester la synchro) :

public class Synchro
{
// simule un calcul, on demande à l'utilisateur d'appuyer sur entrée
public class Calcul extends Thread
{
private Thread recup;

public Calcul(Thread recup)
{
this.recup = recup;
}

public void run()
{
System.out.println("Tapez entrée pour interrompre le thread");
do
{
try
{
System.in.read(); // simule un calcul qui prend du temps
}
catch (IOException e) {}
recup.interrupt();
}
while (true);
}
}

public class Recup extends Thread
{
public Recup() {}

public void run()
{
do
{
try
{
sleep(2000000000);
}
catch (InterruptedException e) {}
System.out.println("interrompu !"); // on peut utiliser les
// résultats du calcul
}
while (true);
}
}

public Synchro()
{
Recup recup = new Recup();
Calcul calcul = new Calcul(recup);
recup.start();
calcul.start();
}

public static void main(String[] args)
{
new Synchro();
}
}

oliv

on commence par lire la doc wait et notify sont faits pour, pas les
exceptions

a+
--
bruno Causse
http://perso.wanadoo.fr/othello

Causse Bruno wrote:

on commence par lire la doc wait et notify sont faits pour, pas les
exceptions

J'avais essayé avec wait, et je reçois des IllegalMonitorStateException.
Comment utiliser ces méthodes ?

merci,
oliv

olivier girant <olivier.girant@_libre_.fr> wrote:

J'avais essayé avec wait, et je reçois des IllegalMonitorStateException.
Comment utiliser ces méthodes ?

merci,
oliv

sur google tu tapes "producteur consommateur thread java"

a+
--
bruno Causse
http://perso.wanadoo.fr/othello

Causse Bruno wrote:

olivier girant <olivier.girant@_libre_.fr> wrote:

J'avais essayé avec wait, et je reçois des IllegalMonitorStateException.
Comment utiliser ces méthodes ?

merci,
oliv

sur google tu tapes "producteur consommateur thread java"

Ok, il me manquait des synchronized...

Olivier wrote:

Bonjour

J'aimerais savoir comment faire synchoniser deux processus A et B
en java fonctionnant de la manière suivante :

A s'endort
B fait des traitements, et quand une donnée est disponible après
calculs, réveille A. Puis A se rendort à nouveau, B continue de
calculer et réveille A, ainsi de suite...

Et puis comment faire aussi lorsque A représente plusieurs processus,
en gros, c'est plusieurs threads qui se disent à partir d'un signal
de B qu'ils ont le droit de travailler.

Merci de vos éclaircissements,
oliv

En fait, il te faut utiliser une structure de données de type file/queue
ou FIFO (First In First, premier rentré premier sorti, le contraire
d'une pile ).
Cette structure va avoir une methode put et take par exemple.
Tu lances ton thread A qui fait un take et comme y'a rien il s'endort à
l'intérieur du take.
Tu lances ton thread B, apres son calcul, B put son resultat dans la
structure ce qui reveille A, etc....
Ces structures existent en lib open source chez Doug Lea
(http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/intro.html).
Dans ton cas par exemple un BoundedLinkedQueue conviendrait
(http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/BoundedLinkedQueue.html).
On peut avoir confiance en cette lib étant donné que Doug Lea a particpé
à l'implementation d'un équivalent de cette lib dans le future JDK
1.5/5.0 (package java.util.concurrent
http://java.sun.com/j2se/1.5.0/docs/api/java/util/concurrent/package-tree.html).

Dans le cas ou tu as plusieurs thread qui peuvent prendre des bojets à
traiter tu peux jeter un coup à PooledExecutor
(http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/PooledExecutor.html).

Sur ce, bonne nuit.