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.
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
olivier girant
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 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();
}
}
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
no.bcausse.spam
olivier girant 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
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
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
olivier girant
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
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 ?
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...
Franck Arnulfo
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.
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).
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).